[INFO] fetching crate fidget-jit 0.5.1...
[INFO] checking fidget-jit-0.5.1 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate fidget-jit 0.5.1 into /workspace/builds/worker-6-tc2/source
[INFO] started tweaking crates.io crate fidget-jit 0.5.1
[INFO] finished tweaking crates.io crate fidget-jit 0.5.1
[INFO] tweaked toml for crates.io crate fidget-jit 0.5.1 written to /workspace/builds/worker-6-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate fidget-jit 0.5.1 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 fidget-jit 0.5.1 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 9f694ebcfdb2ac5957161cc06faf80c53e8f2c4dcdca65b8df96eece0fd70dc3
[INFO] running `Command { std: "docker" "start" "9f694ebcfdb2ac5957161cc06faf80c53e8f2c4dcdca65b8df96eece0fd70dc3", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9f694ebcfdb2ac5957161cc06faf80c53e8f2c4dcdca65b8df96eece0fd70dc3", 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" "9f694ebcfdb2ac5957161cc06faf80c53e8f2c4dcdca65b8df96eece0fd70dc3" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9f694ebcfdb2ac5957161cc06faf80c53e8f2c4dcdca65b8df96eece0fd70dc3", 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" "9f694ebcfdb2ac5957161cc06faf80c53e8f2c4dcdca65b8df96eece0fd70dc3" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]    Compiling mutants v0.0.3
[INFO] [stderr]    Compiling facet-core v0.46.5
[INFO] [stderr]     Checking impls v1.0.3
[INFO] [stderr]     Checking const-fnv1a-hash v1.1.0
[INFO] [stderr]     Checking bytemuck v1.25.2
[INFO] [stderr]    Compiling matrixmultiply v0.3.11
[INFO] [stderr]     Checking allocator-api2 v0.4.0
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]     Checking approx v0.5.1
[INFO] [stderr]     Checking safe_arch v1.2.0
[INFO] [stderr]     Checking num-integer v0.1.47
[INFO] [stderr]    Compiling facet v0.46.5
[INFO] [stderr]     Checking wide v1.7.1
[INFO] [stderr]     Checking num-rational v0.4.2
[INFO] [stderr]    Compiling bitflags v2.13.2
[INFO] [stderr]     Checking either v1.18.0
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling unsynn v0.3.0
[INFO] [stderr]     Checking smallvec v2.0.0-beta.1
[INFO] [stderr]     Checking rayon v1.12.0
[INFO] [stderr]    Compiling syn v3.0.6
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking ordered-float v5.5.0
[INFO] [stderr]    Compiling proc-macro-error-attr3 v3.1.1
[INFO] [stderr]     Checking memmap2 v0.9.11
[INFO] [stderr]     Checking workspace-hack v0.1.0
[INFO] [stderr]    Compiling facet-macro-types v0.46.5
[INFO] [stderr]    Compiling fidget-jit v0.5.1 (/opt/rustwide/workdir)
[INFO] [stderr]    Compiling facet-macro-parse v0.46.5
[INFO] [stderr]    Compiling facet-macros-impl v0.46.5
[INFO] [stderr]     Checking facet-path v0.46.5
[INFO] [stderr]    Compiling proc-macro-error3 v3.1.1
[INFO] [stderr]     Checking facet-reflect v0.46.5
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling thiserror-impl v2.0.21
[INFO] [stderr]     Checking thiserror v2.0.21
[INFO] [stderr]    Compiling strum_macros v0.28.0
[INFO] [stderr]    Compiling dynasm v5.1.0
[INFO] [stderr]     Checking serde v1.0.229
[INFO] [stderr]     Checking strum v0.28.0
[INFO] [stderr]     Checking num-complex v0.4.6
[INFO] [stderr]    Compiling facet-macros v0.46.5
[INFO] [stderr]     Checking simba v0.10.2
[INFO] [stderr]     Checking nalgebra v0.35.0
[INFO] [stderr]     Checking dynasmrt v5.1.0
[INFO] [stderr]     Checking fidget-core v0.5.1
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/float_slice.rs:90:26
[INFO] [stdout]    |
[INFO] [stdout] 90 |             ; vmovups Ry(reg(dst_reg)), [rsp + 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] 90 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(dst_reg))), [rsp + sp_offset]
[INFO] [stdout]    |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:100:45
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; vmovups [rsp + sp_offset], Ry(reg(src_reg))
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; vmovups [rsp + sp_offset], Ry(<u8 as Into<_>>::into(reg(src_reg)))
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:108:26
[INFO] [stdout]     |
[INFO] [stdout] 108 |             ; vmovups Ry(reg(out_reg)), [r8 + rcx] // offset by array
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 108 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(out_reg))), [r8 + rcx] // offset by array
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:116:38
[INFO] [stdout]     |
[INFO] [stdout] 116 |             ; vmovups [r8 + rcx], Ry(reg(arg_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 |             ; vmovups [r8 + rcx], Ry(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:190:26
[INFO] [stdout]     |
[INFO] [stdout] 190 |             ; vpaddd  Ry(reg(out_reg)), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 190 |             ; vpaddd  Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:190:50
[INFO] [stdout]     |
[INFO] [stdout] 190 |             ; vpaddd  Ry(reg(out_reg)), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 190 |             ; vpaddd  Ry(reg(out_reg)), ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                  ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:197:26
[INFO] [stdout]     |
[INFO] [stdout] 197 |             ; vpmulld Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |             ; vpmulld Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:201:26
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vpaddd  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vpaddd  Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:201:44
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vpaddd  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vpaddd  Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:203:32
[INFO] [stdout]     |
[INFO] [stdout] 203 |             ; vpsrld  ymm2, Ry(reg(out_reg)), 28
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 |             ; vpsrld  ymm2, Ry(<u8 as Into<_>>::into(reg(out_reg))), 28
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:209:38
[INFO] [stdout]     |
[INFO] [stdout] 209 |             ; vpxor   ymm3, ymm3, Ry(reg(out_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 |             ; vpxor   ymm3, ymm3, Ry(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:217:26
[INFO] [stdout]     |
[INFO] [stdout] 217 |             ; vpxor   Ry(reg(out_reg)), ymm1, ymm3
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 |             ; vpxor   Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, ymm3
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:232:26
[INFO] [stdout]     |
[INFO] [stdout] 232 |             ; vpmulld Ry(reg(out_reg)), Ry(reg(arg_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 232 |             ; vpmulld Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(arg_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:238:26
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vpaddd  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vpaddd  Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:238:44
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vpaddd  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vpaddd  Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:241:32
[INFO] [stdout]     |
[INFO] [stdout] 241 |             ; vpsrld  ymm1, Ry(reg(out_reg)), 28
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 |             ; vpsrld  ymm1, Ry(<u8 as Into<_>>::into(reg(out_reg))), 28
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:249:38
[INFO] [stdout]     |
[INFO] [stdout] 249 |             ; vpxor   ymm2, ymm2, Ry(reg(out_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 |             ; vpxor   ymm2, ymm2, Ry(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:266:26
[INFO] [stdout]     |
[INFO] [stdout] 266 |             ; vpor    Ry(reg(out_reg)), ymm2, ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 266 |             ; vpor    Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm2, ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:272:26
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vaddps  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vaddps  Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:272:44
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vaddps  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vaddps  Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:283:26
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vmovups Ry(reg(out_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:283:44
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vmovups Ry(reg(out_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vmovups Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:290:24
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vpxor Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vpxor Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:290:48
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vpxor Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vpxor Ry(reg(out_reg)), ymm0, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:297:24
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vpand Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vpand Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:297:48
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vpand Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vpand Ry(reg(out_reg)), ymm0, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:306:25
[INFO] [stdout]     |
[INFO] [stdout] 306 |             ; vdivps Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 306 |             ; vdivps Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:306:49
[INFO] [stdout]     |
[INFO] [stdout] 306 |             ; vdivps Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 306 |             ; vdivps Ry(reg(out_reg)), ymm0, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:311:26
[INFO] [stdout]     |
[INFO] [stdout] 311 |             ; vsqrtps Ry(reg(out_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 311 |             ; vsqrtps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:311:44
[INFO] [stdout]     |
[INFO] [stdout] 311 |             ; vsqrtps Ry(reg(out_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 311 |             ; vsqrtps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:316:25
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vmulps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:316:61
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:322:27
[INFO] [stdout]     |
[INFO] [stdout] 322 |             ; vroundps Ry(reg(out_reg)), Ry(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 322 |             ; vroundps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:322:45
[INFO] [stdout]     |
[INFO] [stdout] 322 |             ; vroundps Ry(reg(out_reg)), Ry(reg(lhs_reg)), 1
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 322 |             ; vroundps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:327:27
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vroundps Ry(reg(out_reg)), Ry(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vroundps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:327:45
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vroundps Ry(reg(out_reg)), Ry(reg(lhs_reg)), 2
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vroundps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg))), 2
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:336:38
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vandps  ymm1, ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vandps  ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:341:25
[INFO] [stdout]     |
[INFO] [stdout] 341 |             ; vaddps Ry(reg(out_reg)), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 341 |             ; vaddps Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:341:49
[INFO] [stdout]     |
[INFO] [stdout] 341 |             ; vaddps Ry(reg(out_reg)), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 341 |             ; vaddps Ry(reg(out_reg)), ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:342:27
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; vroundps Ry(reg(out_reg)), Ry(reg(out_reg)), 3
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; vroundps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), 3
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:342:45
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; vroundps Ry(reg(out_reg)), Ry(reg(out_reg)), 3
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; vroundps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), 3
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:348:25
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vaddps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vaddps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:348:61
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vaddps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vaddps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:353:25
[INFO] [stdout]     |
[INFO] [stdout] 353 |             ; vsubps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 353 |             ; vsubps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:353:61
[INFO] [stdout]     |
[INFO] [stdout] 353 |             ; vsubps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 353 |             ; vsubps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:358:25
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vmulps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:358:61
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:363:25
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vdivps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vdivps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:363:61
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vdivps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vdivps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:375:54
[INFO] [stdout]     |
[INFO] [stdout] 375 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:376:54
[INFO] [stdout]     |
[INFO] [stdout] 376 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 376 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:380:25
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; vmaxps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; vmaxps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:380:61
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; vmaxps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; vmaxps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:383:24
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vorps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:383:42
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vorps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:389:54
[INFO] [stdout]     |
[INFO] [stdout] 389 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 389 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:390:54
[INFO] [stdout]     |
[INFO] [stdout] 390 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 390 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:394:25
[INFO] [stdout]     |
[INFO] [stdout] 394 |             ; vminps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 394 |             ; vminps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:394:61
[INFO] [stdout]     |
[INFO] [stdout] 394 |             ; vminps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 394 |             ; vminps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:399:24
[INFO] [stdout]     |
[INFO] [stdout] 399 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 399 |             ; vorps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:399:42
[INFO] [stdout]     |
[INFO] [stdout] 399 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 399 |             ; vorps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:411:39
[INFO] [stdout]     |
[INFO] [stdout] 411 |             ; vcmpeqps ymm1, ymm1, Ry(reg(arg_reg))
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 |             ; vcmpeqps ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:413:24
[INFO] [stdout]     |
[INFO] [stdout] 413 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 413 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:414:31
[INFO] [stdout]     |
[INFO] [stdout] 414 |             ; vbroadcastss Ry(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 414 |             ; vbroadcastss Ry(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:414:49
[INFO] [stdout]     |
[INFO] [stdout] 414 |             ; vbroadcastss Ry(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 414 |             ; vbroadcastss Ry(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:415:25
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:415:43
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:422:39
[INFO] [stdout]     |
[INFO] [stdout] 422 |             ; vcmpeqps ymm1, ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 422 |             ; vcmpeqps ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:426:37
[INFO] [stdout]     |
[INFO] [stdout] 426 |             ; vandpd ymm1, ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 426 |             ; vandpd ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:427:37
[INFO] [stdout]     |
[INFO] [stdout] 427 |             ; vandpd ymm2, ymm2, Ry(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 427 |             ; vandpd ymm2, ymm2, Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:428:24
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; vorpd Ry(reg(out_reg)), ymm1, ymm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; vorpd Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, ymm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:435:39
[INFO] [stdout]     |
[INFO] [stdout] 435 |             ; vcmpeqps ymm1, ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 435 |             ; vcmpeqps ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:439:37
[INFO] [stdout]     |
[INFO] [stdout] 439 |             ; vandpd ymm1, ymm1, Ry(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 439 |             ; vandpd ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:440:37
[INFO] [stdout]     |
[INFO] [stdout] 440 |             ; vandpd ymm2, ymm2, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 440 |             ; vandpd ymm2, ymm2, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:441:24
[INFO] [stdout]     |
[INFO] [stdout] 441 |             ; vorpd Ry(reg(out_reg)), ymm1, ymm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 441 |             ; vorpd Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, ymm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:448:54
[INFO] [stdout]     |
[INFO] [stdout] 448 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 448 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:449:54
[INFO] [stdout]     |
[INFO] [stdout] 449 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 449 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:453:51
[INFO] [stdout]     |
[INFO] [stdout] 453 |             ; vcmpltps ymm2, Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 453 |             ; vcmpltps ymm2, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                   ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:456:51
[INFO] [stdout]     |
[INFO] [stdout] 456 |             ; vcmpgtps ymm3, Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 456 |             ; vcmpgtps ymm3, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                   ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:460:24
[INFO] [stdout]     |
[INFO] [stdout] 460 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 460 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:461:31
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vbroadcastss Ry(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vbroadcastss Ry(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:461:49
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vbroadcastss Ry(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vbroadcastss Ry(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:464:25
[INFO] [stdout]     |
[INFO] [stdout] 464 |             ; vandps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 464 |             ; vandps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:464:43
[INFO] [stdout]     |
[INFO] [stdout] 464 |             ; vandps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 464 |             ; vandps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm2
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:471:24
[INFO] [stdout]     |
[INFO] [stdout] 471 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 |             ; vorps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:471:42
[INFO] [stdout]     |
[INFO] [stdout] 471 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 |             ; vorps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm2
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:474:24
[INFO] [stdout]     |
[INFO] [stdout] 474 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 474 |             ; vorps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:474:42
[INFO] [stdout]     |
[INFO] [stdout] 474 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 474 |             ; vorps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:480:24
[INFO] [stdout]     |
[INFO] [stdout] 480 |             ; vmovd Rx(IMM_REG), eax
[INFO] [stdout]     |                        ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 480 |             ; vmovd Rx(<u8 as Into<_>>::into(IMM_REG)), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:481:31
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vbroadcastss Ry(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                               ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vbroadcastss Ry(<u8 as Into<_>>::into(IMM_REG)), Rx(IMM_REG)
[INFO] [stdout]     |                               ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:481:44
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vbroadcastss Ry(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                                            ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vbroadcastss Ry(IMM_REG), Rx(<u8 as Into<_>>::into(IMM_REG))
[INFO] [stdout]     |                                            ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:531:41
[INFO] [stdout]     |
[INFO] [stdout] 531 |             ; vmovups [rsp + 0x180], Ry(reg(arg_reg))
[INFO] [stdout]     |                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 531 |             ; vmovups [rsp + 0x180], Ry(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:573:26
[INFO] [stdout]     |
[INFO] [stdout] 573 |             ; vmovups Ry(reg(out_reg)), [rsp + 0x180]
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 573 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(out_reg))), [rsp + 0x180]
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:617:41
[INFO] [stdout]     |
[INFO] [stdout] 617 |             ; vmovups [rsp + 0x180], Ry(reg(lhs_reg))
[INFO] [stdout]     |                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 617 |             ; vmovups [rsp + 0x180], Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:618:41
[INFO] [stdout]     |
[INFO] [stdout] 618 |             ; vmovups [rsp + 0x200], Ry(reg(rhs_reg))
[INFO] [stdout]     |                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 618 |             ; vmovups [rsp + 0x200], Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:668:26
[INFO] [stdout]     |
[INFO] [stdout] 668 |             ; vmovups Ry(reg(out_reg)), [rsp + 0x180]
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 668 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(out_reg))), [rsp + 0x180]
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/grad_slice.rs:79:26
[INFO] [stdout]    |
[INFO] [stdout] 79 |             ; vmovups Rx(reg(dst_reg)), [rsp + 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] 79 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(dst_reg))), [rsp + sp_offset]
[INFO] [stdout]    |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/grad_slice.rs:89:45
[INFO] [stdout]    |
[INFO] [stdout] 89 |             ; vmovups [rsp + sp_offset], Rx(reg(src_reg))
[INFO] [stdout]    |                                             ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 |             ; vmovups [rsp + sp_offset], Rx(<u8 as Into<_>>::into(reg(src_reg)))
[INFO] [stdout]    |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/grad_slice.rs:96:26
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; vmovups Rx(reg(out_reg)), [r8 + rcx] // offset by array
[INFO] [stdout]    |                          ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), [r8 + rcx] // offset by array
[INFO] [stdout]    |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:104:38
[INFO] [stdout]     |
[INFO] [stdout] 104 |             ; vmovups [r8 + rcx], Rx(reg(arg_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 |             ; vmovups [r8 + rcx], Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:158:26
[INFO] [stdout]     |
[INFO] [stdout] 158 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:158:44
[INFO] [stdout]     |
[INFO] [stdout] 158 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:165:24
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:165:48
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:173:26
[INFO] [stdout]     |
[INFO] [stdout] 173 |             ; vcomiss Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:177:26
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:177:44
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:183:24
[INFO] [stdout]     |
[INFO] [stdout] 183 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:183:48
[INFO] [stdout]     |
[INFO] [stdout] 183 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:194:30
[INFO] [stdout]     |
[INFO] [stdout] 194 |             ; movss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 194 |             ; movss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:206:31
[INFO] [stdout]     |
[INFO] [stdout] 206 |             ; vdivps xmm0, Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 |             ; vdivps xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:211:30
[INFO] [stdout]     |
[INFO] [stdout] 211 |             ; divss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 |             ; divss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:213:26
[INFO] [stdout]     |
[INFO] [stdout] 213 |             ; vmovups Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:214:24
[INFO] [stdout]     |
[INFO] [stdout] 214 |             ; movss Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:221:38
[INFO] [stdout]     |
[INFO] [stdout] 221 |             ; vsqrtss xmm0, xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 |             ; vsqrtss xmm0, xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:233:31
[INFO] [stdout]     |
[INFO] [stdout] 233 |             ; vdivps xmm0, Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 |             ; vdivps xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:236:38
[INFO] [stdout]     |
[INFO] [stdout] 236 |             ; vsqrtss xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 236 |             ; vsqrtss xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:238:26
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vmovups Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:239:25
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:239:43
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vmovss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:254:37
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vbroadcastss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vbroadcastss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:256:25
[INFO] [stdout]     |
[INFO] [stdout] 256 |             ; vmulps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 256 |             ; vmulps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:256:49
[INFO] [stdout]     |
[INFO] [stdout] 256 |             ; vmulps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 256 |             ; vmulps Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:262:51
[INFO] [stdout]     |
[INFO] [stdout] 262 |             ; vroundss xmm1, Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 |             ; vroundss xmm1, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                                   ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:263:24
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:263:60
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:264:24
[INFO] [stdout]     |
[INFO] [stdout] 264 |             ; movss Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:269:51
[INFO] [stdout]     |
[INFO] [stdout] 269 |             ; vroundss xmm1, Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 269 |             ; vroundss xmm1, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 2
[INFO] [stdout]     |                                                   ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:270:24
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:270:60
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:271:24
[INFO] [stdout]     |
[INFO] [stdout] 271 |             ; movss Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:279:38
[INFO] [stdout]     |
[INFO] [stdout] 279 |             ; vandps  xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 279 |             ; vandps  xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:283:25
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:283:49
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:284:27
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vroundss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:284:63
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 3
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:290:25
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vaddps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:290:61
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:295:25
[INFO] [stdout]     |
[INFO] [stdout] 295 |             ; vsubps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 |             ; vsubps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:295:61
[INFO] [stdout]     |
[INFO] [stdout] 295 |             ; vsubps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 |             ; vsubps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:301:37
[INFO] [stdout]     |
[INFO] [stdout] 301 |             ; vbroadcastss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 301 |             ; vbroadcastss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:302:37
[INFO] [stdout]     |
[INFO] [stdout] 302 |             ; vmulps xmm1, xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 302 |             ; vmulps xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:303:37
[INFO] [stdout]     |
[INFO] [stdout] 303 |             ; vbroadcastss xmm2, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 303 |             ; vbroadcastss xmm2, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:304:37
[INFO] [stdout]     |
[INFO] [stdout] 304 |             ; vmulps xmm2, xmm2, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 304 |             ; vmulps xmm2, xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:307:49
[INFO] [stdout]     |
[INFO] [stdout] 307 |             ; vmulss xmm2, Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 |             ; vmulss xmm2, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:308:26
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ; vmovups Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:309:25
[INFO] [stdout]     |
[INFO] [stdout] 309 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 309 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:309:43
[INFO] [stdout]     |
[INFO] [stdout] 309 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 309 |             ; vmovss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:316:37
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vbroadcastss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vbroadcastss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:317:37
[INFO] [stdout]     |
[INFO] [stdout] 317 |             ; vmulps xmm1, xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 317 |             ; vmulps xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:320:37
[INFO] [stdout]     |
[INFO] [stdout] 320 |             ; vbroadcastss xmm2, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 320 |             ; vbroadcastss xmm2, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:321:37
[INFO] [stdout]     |
[INFO] [stdout] 321 |             ; vmulps xmm2, xmm2, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 321 |             ; vmulps xmm2, xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:327:49
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vmulss xmm2, Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vmulss xmm2, Rx(reg(rhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:334:49
[INFO] [stdout]     |
[INFO] [stdout] 334 |             ; vdivss xmm2, Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 334 |             ; vdivss xmm2, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:335:26
[INFO] [stdout]     |
[INFO] [stdout] 335 |             ; vmovups Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 335 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:336:25
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:336:43
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vmovss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:349:26
[INFO] [stdout]     |
[INFO] [stdout] 349 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:349:44
[INFO] [stdout]     |
[INFO] [stdout] 349 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:354:26
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vmovups Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:354:44
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vmovups Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:358:24
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:358:60
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:359:27
[INFO] [stdout]     |
[INFO] [stdout] 359 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 359 |             ; vcmpeqss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:359:63
[INFO] [stdout]     |
[INFO] [stdout] 359 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 359 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:363:26
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:363:44
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:372:26
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:372:44
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:377:26
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:377:44
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:381:24
[INFO] [stdout]     |
[INFO] [stdout] 381 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 381 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:381:60
[INFO] [stdout]     |
[INFO] [stdout] 381 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 381 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:382:27
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vcmpeqss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:382:63
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:386:26
[INFO] [stdout]     |
[INFO] [stdout] 386 |             ; vmovups Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:386:44
[INFO] [stdout]     |
[INFO] [stdout] 386 |             ; vmovups Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:403:33
[INFO] [stdout]     |
[INFO] [stdout] 403 |             ; vcmpeqss xmm1, Rx(reg(arg_reg)), xmm1
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 403 |             ; vcmpeqss xmm1, Rx(<u8 as Into<_>>::into(reg(arg_reg))), xmm1
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:404:25
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; vandps Rx(reg(out_reg)), xmm1, Rx(reg(i))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; vandps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, Rx(reg(i))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:404:49
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; vandps Rx(reg(out_reg)), xmm1, Rx(reg(i))
[INFO] [stdout]     |                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; vandps Rx(reg(out_reg)), xmm1, Rx(<u8 as Into<_>>::into(reg(i)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:410:33
[INFO] [stdout]     |
[INFO] [stdout] 410 |             ; vcmpeqss xmm1, Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 410 |             ; vcmpeqss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:415:37
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:416:37
[INFO] [stdout]     |
[INFO] [stdout] 416 |             ; vandpd xmm2, xmm2, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 |             ; vandpd xmm2, xmm2, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:417:24
[INFO] [stdout]     |
[INFO] [stdout] 417 |             ; vorpd Rx(reg(out_reg)), xmm1, xmm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 417 |             ; vorpd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, xmm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:423:33
[INFO] [stdout]     |
[INFO] [stdout] 423 |             ; vcmpeqss xmm1, Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 423 |             ; vcmpeqss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:428:37
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; vandpd xmm1, xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; vandpd xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:429:37
[INFO] [stdout]     |
[INFO] [stdout] 429 |             ; vandpd xmm2, xmm2, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 429 |             ; vandpd xmm2, xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:430:24
[INFO] [stdout]     |
[INFO] [stdout] 430 |             ; vorpd Rx(reg(out_reg)), xmm1, xmm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 430 |             ; vorpd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, xmm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:437:31
[INFO] [stdout]     |
[INFO] [stdout] 437 |             ; movq    rax, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 437 |             ; movq    rax, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:452:26
[INFO] [stdout]     |
[INFO] [stdout] 452 |             ; vmovd   Rx(reg(out_reg)), eax
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; vmovd   Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:455:26
[INFO] [stdout]     |
[INFO] [stdout] 455 |             ; addss   Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 455 |             ; addss   Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:462:31
[INFO] [stdout]     |
[INFO] [stdout] 462 |             ; movq    rax, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 462 |             ; movq    rax, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:463:30
[INFO] [stdout]     |
[INFO] [stdout] 463 |             ; movq    r8, Rx(reg(rhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 463 |             ; movq    r8, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:489:26
[INFO] [stdout]     |
[INFO] [stdout] 489 |             ; vmovq   Rx(reg(out_reg)), r8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 489 |             ; vmovq   Rx(<u8 as Into<_>>::into(reg(out_reg))), r8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:495:26
[INFO] [stdout]     |
[INFO] [stdout] 495 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 495 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:495:44
[INFO] [stdout]     |
[INFO] [stdout] 495 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 495 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:502:24
[INFO] [stdout]     |
[INFO] [stdout] 502 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 502 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:508:24
[INFO] [stdout]     |
[INFO] [stdout] 508 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 508 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:513:25
[INFO] [stdout]     |
[INFO] [stdout] 513 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 513 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:513:61
[INFO] [stdout]     |
[INFO] [stdout] 513 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 513 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:518:24
[INFO] [stdout]     |
[INFO] [stdout] 518 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 518 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:528:24
[INFO] [stdout]     |
[INFO] [stdout] 528 |             ; vpxor Rx(IMM_REG), Rx(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                        ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 |             ; vpxor Rx(<u8 as Into<_>>::into(IMM_REG)), Rx(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                        ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:528:50
[INFO] [stdout]     |
[INFO] [stdout] 528 |             ; vpxor Rx(IMM_REG), Rx(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                                                  ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 |             ; vpxor Rx(IMM_REG), Rx(IMM_REG), Rx(<u8 as Into<_>>::into(IMM_REG))
[INFO] [stdout]     |                                                  ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:530:24
[INFO] [stdout]     |
[INFO] [stdout] 530 |             ; vmovd Rx(IMM_REG), eax
[INFO] [stdout]     |                        ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 530 |             ; vmovd Rx(<u8 as Into<_>>::into(IMM_REG)), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:578:49
[INFO] [stdout]     |
[INFO] [stdout] 578 |             ; vmovsd xmm0, Rx(reg(arg_reg)), Rx(reg(arg_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 578 |             ; vmovsd xmm0, Rx(reg(arg_reg)), Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:579:32
[INFO] [stdout]     |
[INFO] [stdout] 579 |             ; vpshufd xmm1, Rx(reg(arg_reg)), 0b1110
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 579 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(arg_reg))), 0b1110
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:604:30
[INFO] [stdout]     |
[INFO] [stdout] 604 |             ; vpunpcklqdq Rx(reg(out_reg)), xmm0, xmm1
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 604 |             ; vpunpcklqdq Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, xmm1
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:640:32
[INFO] [stdout]     |
[INFO] [stdout] 640 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 0b1110
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 640 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b1110
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:641:49
[INFO] [stdout]     |
[INFO] [stdout] 641 |             ; vmovsd xmm2, Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 641 |             ; vmovsd xmm2, Rx(reg(rhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:642:32
[INFO] [stdout]     |
[INFO] [stdout] 642 |             ; vpshufd xmm3, Rx(reg(rhs_reg)), 0b1110
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 642 |             ; vpshufd xmm3, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b1110
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:643:49
[INFO] [stdout]     |
[INFO] [stdout] 643 |             ; vmovsd xmm0, Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 643 |             ; vmovsd xmm0, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:668:30
[INFO] [stdout]     |
[INFO] [stdout] 668 |             ; vpunpcklqdq Rx(reg(out_reg)), xmm0, xmm1
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 668 |             ; vpunpcklqdq Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, xmm1
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/interval.rs:73:23
[INFO] [stdout]    |
[INFO] [stdout] 73 |             ; movq Rx(reg(dst_reg)), [rsp + 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] 73 |             ; movq Rx(<u8 as Into<_>>::into(reg(dst_reg))), [rsp + sp_offset]
[INFO] [stdout]    |                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/interval.rs:84:42
[INFO] [stdout]    |
[INFO] [stdout] 84 |             ; movq [rsp + sp_offset], Rx(reg(src_reg))
[INFO] [stdout]    |                                          ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |             ; movq [rsp + sp_offset], Rx(<u8 as Into<_>>::into(reg(src_reg)))
[INFO] [stdout]    |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/interval.rs:90:24
[INFO] [stdout]    |
[INFO] [stdout] 90 |             ; vmovq Rx(reg(out_reg)), [rdi + pos]
[INFO] [stdout]    |                        ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 90 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), [rdi + pos]
[INFO] [stdout]    |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/interval.rs:96:37
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; vmovq [rcx + pos], Rx(reg(arg_reg))
[INFO] [stdout]    |                                     ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; vmovq [rcx + pos], Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]    |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:149:24
[INFO] [stdout]     |
[INFO] [stdout] 149 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:149:42
[INFO] [stdout]     |
[INFO] [stdout] 149 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:154:26
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; vpshufd Rx(reg(out_reg)), Rx(reg(lhs_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:154:44
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; vpshufd Rx(reg(out_reg)), Rx(reg(lhs_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; vpshufd Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11110001u8 as i8
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:157:25
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:157:43
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:167:32
[INFO] [stdout]     |
[INFO] [stdout] 167 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 167 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:174:31
[INFO] [stdout]     |
[INFO] [stdout] 174 |             ; comiss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 174 |             ; comiss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:179:24
[INFO] [stdout]     |
[INFO] [stdout] 179 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:179:42
[INFO] [stdout]     |
[INFO] [stdout] 179 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:187:37
[INFO] [stdout]     |
[INFO] [stdout] 187 |             ; vxorps xmm0, xmm0, Rx(reg(lhs_reg)) // xor to swap sign bits
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 |             ; vxorps xmm0, xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg))) // xor to swap sign bits
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:188:26
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; vpshufd Rx(reg(out_reg)), xmm0, 1 // swap lo and 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] 188 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, 1 // swap lo and hi
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:199:25
[INFO] [stdout]     |
[INFO] [stdout] 199 |             ; vandps Rx(reg(out_reg)), Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 |             ; vandps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:199:43
[INFO] [stdout]     |
[INFO] [stdout] 199 |             ; vandps Rx(reg(out_reg)), Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 |             ; vandps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:202:32
[INFO] [stdout]     |
[INFO] [stdout] 202 |             ; vpshufd xmm0, Rx(reg(out_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 202 |             ; vpshufd xmm0, Rx(<u8 as Into<_>>::into(reg(out_reg))), 0b11110001u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:204:32
[INFO] [stdout]     |
[INFO] [stdout] 204 |             ; vcomiss xmm0, Rx(reg(out_reg)) // Compare abs(hi) vs abs(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] 204 |             ; vcomiss xmm0, Rx(<u8 as Into<_>>::into(reg(out_reg))) // Compare abs(hi) vs abs(lo)
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:207:26
[INFO] [stdout]     |
[INFO] [stdout] 207 |             ; vpshufd Rx(reg(out_reg)), Rx(reg(out_reg)), 0b11110011u8 as i8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), 0b11110011u8 as i8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:207:44
[INFO] [stdout]     |
[INFO] [stdout] 207 |             ; vpshufd Rx(reg(out_reg)), Rx(reg(out_reg)), 0b11110011u8 as i8
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 |             ; vpshufd Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 0b11110011u8 as i8
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:212:26
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; vpinsrd Rx(reg(out_reg)), Rx(reg(out_reg)), eax, 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] 212 |             ; vpinsrd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), eax, 0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:222:26
[INFO] [stdout]     |
[INFO] [stdout] 222 |             ; vcomiss Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:224:32
[INFO] [stdout]     |
[INFO] [stdout] 224 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 1 // extract high element
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 224 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1 // extract high element
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:229:26
[INFO] [stdout]     |
[INFO] [stdout] 229 |             ; pcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 229 |             ; pcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:229:44
[INFO] [stdout]     |
[INFO] [stdout] 229 |             ; pcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 229 |             ; pcmpeqw Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:230:24
[INFO] [stdout]     |
[INFO] [stdout] 230 |             ; pslld Rx(reg(out_reg)), 23
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 |             ; pslld Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:231:24
[INFO] [stdout]     |
[INFO] [stdout] 231 |             ; psrld Rx(reg(out_reg)), 1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 |             ; psrld Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:239:25
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vdivps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vdivps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:239:49
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vdivps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vdivps Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:240:25
[INFO] [stdout]     |
[INFO] [stdout] 240 |             ; pshufd Rx(reg(out_reg)), Rx(reg(out_reg)), 0b0001
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 |             ; pshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), 0b0001
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:240:43
[INFO] [stdout]     |
[INFO] [stdout] 240 |             ; pshufd Rx(reg(out_reg)), Rx(reg(out_reg)), 0b0001
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 |             ; pshufd Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 0b0001
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:250:32
[INFO] [stdout]     |
[INFO] [stdout] 250 |             ; vcomiss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 250 |             ; vcomiss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:254:26
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vsqrtps Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vsqrtps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:254:44
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vsqrtps Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vsqrtps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:259:27
[INFO] [stdout]     |
[INFO] [stdout] 259 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:259:63
[INFO] [stdout]     |
[INFO] [stdout] 259 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:260:43
[INFO] [stdout]     |
[INFO] [stdout] 260 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 260 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:261:43
[INFO] [stdout]     |
[INFO] [stdout] 261 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:270:49
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vmulps xmm2, Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vmulps xmm2, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:272:32
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:275:32
[INFO] [stdout]     |
[INFO] [stdout] 275 |             ; vcomiss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 |             ; vcomiss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:279:24
[INFO] [stdout]     |
[INFO] [stdout] 279 |             ; vmovq Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 279 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:284:26
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vpshufd Rx(reg(out_reg)), xmm2, 0b11110001u8 as i8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2, 0b11110001u8 as i8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:289:26
[INFO] [stdout]     |
[INFO] [stdout] 289 |             ; vpshufd Rx(reg(out_reg)), xmm2, 1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 289 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2, 1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:290:25
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vmaxss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vmaxss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:290:43
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vmaxss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vmaxss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:292:43
[INFO] [stdout]     |
[INFO] [stdout] 292 |             ; vpsllq Rx(reg(out_reg)), Rx(reg(out_reg)), 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] 292 |             ; vpsllq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 32
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:300:27
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; vroundps Rx(reg(out_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; vroundps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:300:45
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; vroundps Rx(reg(out_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; vroundps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:305:27
[INFO] [stdout]     |
[INFO] [stdout] 305 |             ; vroundps Rx(reg(out_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 305 |             ; vroundps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:305:45
[INFO] [stdout]     |
[INFO] [stdout] 305 |             ; vroundps Rx(reg(out_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 305 |             ; vroundps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 2
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:314:38
[INFO] [stdout]     |
[INFO] [stdout] 314 |             ; vandps  xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 314 |             ; vandps  xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:319:25
[INFO] [stdout]     |
[INFO] [stdout] 319 |             ; vaddps Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 |             ; vaddps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:319:49
[INFO] [stdout]     |
[INFO] [stdout] 319 |             ; vaddps Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 |             ; vaddps Rx(reg(out_reg)), xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:320:27
[INFO] [stdout]     |
[INFO] [stdout] 320 |             ; vroundps Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 320 |             ; vroundps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:320:45
[INFO] [stdout]     |
[INFO] [stdout] 320 |             ; vroundps Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 320 |             ; vroundps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 3
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:326:25
[INFO] [stdout]     |
[INFO] [stdout] 326 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 326 |             ; vaddps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:326:61
[INFO] [stdout]     |
[INFO] [stdout] 326 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 326 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:331:32
[INFO] [stdout]     |
[INFO] [stdout] 331 |             ; vpshufd xmm1, Rx(reg(rhs_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 331 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b11110001u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:332:25
[INFO] [stdout]     |
[INFO] [stdout] 332 |             ; vsubps Rx(reg(out_reg)), Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 332 |             ; vsubps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:332:43
[INFO] [stdout]     |
[INFO] [stdout] 332 |             ; vsubps Rx(reg(out_reg)), Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 332 |             ; vsubps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:337:32
[INFO] [stdout]     |
[INFO] [stdout] 337 |             ; vpshufd xmm2, Rx(reg(lhs_reg)), 0b01000001_i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b01000001_i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:338:32
[INFO] [stdout]     |
[INFO] [stdout] 338 |             ; vpshufd xmm1, Rx(reg(rhs_reg)), 0b00010001_i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 338 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b00010001_i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:344:26
[INFO] [stdout]     |
[INFO] [stdout] 344 |             ; vpshufd Rx(reg(out_reg)), xmm1, 0b00000001 // out = max(3, 1)
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 344 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, 0b00000001 // out = max(3, 1)
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:345:25
[INFO] [stdout]     |
[INFO] [stdout] 345 |             ; vminss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1 // out[0] is lowest value
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 345 |             ; vminss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm1 // out[0] is lowest value
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:345:43
[INFO] [stdout]     |
[INFO] [stdout] 345 |             ; vminss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1 // out[0] is lowest value
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 345 |             ; vminss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1 // out[0] is lowest value
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:354:28
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vunpcklps Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vunpcklps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:354:46
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vunpcklps Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vunpcklps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:360:26
[INFO] [stdout]     |
[INFO] [stdout] 360 |             ; vcomiss Rx(reg(rhs_reg)), xmm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(rhs_reg))), xmm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:362:32
[INFO] [stdout]     |
[INFO] [stdout] 362 |             ; vpshufd xmm2, Rx(reg(rhs_reg)), 1
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 362 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 1
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:368:27
[INFO] [stdout]     |
[INFO] [stdout] 368 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 368 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:368:63
[INFO] [stdout]     |
[INFO] [stdout] 368 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 368 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:369:43
[INFO] [stdout]     |
[INFO] [stdout] 369 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 369 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:370:43
[INFO] [stdout]     |
[INFO] [stdout] 370 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 370 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:375:32
[INFO] [stdout]     |
[INFO] [stdout] 375 |             ; vpshufd xmm2, Rx(reg(lhs_reg)), 0b01000001_i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b01000001_i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:376:32
[INFO] [stdout]     |
[INFO] [stdout] 376 |             ; vpshufd xmm1, Rx(reg(rhs_reg)), 0b00010001_i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 376 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b00010001_i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:382:26
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vpshufd Rx(reg(out_reg)), xmm1, 0b00000001 // out = max(3, 1)
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, 0b00000001 // out = max(3, 1)
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:383:25
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vminss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1 // out[0] is lowest value
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vminss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm1 // out[0] is lowest value
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:383:43
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vminss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1 // out[0] is lowest value
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vminss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1 // out[0] is lowest value
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:392:28
[INFO] [stdout]     |
[INFO] [stdout] 392 |             ; vunpcklps Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 392 |             ; vunpcklps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:392:46
[INFO] [stdout]     |
[INFO] [stdout] 392 |             ; vunpcklps Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 392 |             ; vunpcklps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:401:32
[INFO] [stdout]     |
[INFO] [stdout] 401 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 0b11111101u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11111101u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:402:32
[INFO] [stdout]     |
[INFO] [stdout] 402 |             ; vcomiss xmm1, Rx(reg(rhs_reg)) // compare lhs.upper and rhs.lower
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 |             ; vcomiss xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))) // compare lhs.upper and rhs.lower
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:407:32
[INFO] [stdout]     |
[INFO] [stdout] 407 |             ; vpshufd xmm1, Rx(reg(rhs_reg)), 0b11111101u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 407 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b11111101u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:408:32
[INFO] [stdout]     |
[INFO] [stdout] 408 |             ; vcomiss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 408 |             ; vcomiss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:413:25
[INFO] [stdout]     |
[INFO] [stdout] 413 |             ; vmaxps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 413 |             ; vmaxps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:413:61
[INFO] [stdout]     |
[INFO] [stdout] 413 |             ; vmaxps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 413 |             ; vmaxps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:420:27
[INFO] [stdout]     |
[INFO] [stdout] 420 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 420 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:420:63
[INFO] [stdout]     |
[INFO] [stdout] 420 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 420 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:421:43
[INFO] [stdout]     |
[INFO] [stdout] 421 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:422:43
[INFO] [stdout]     |
[INFO] [stdout] 422 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 422 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:427:24
[INFO] [stdout]     |
[INFO] [stdout] 427 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 427 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:427:42
[INFO] [stdout]     |
[INFO] [stdout] 427 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 427 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:434:24
[INFO] [stdout]     |
[INFO] [stdout] 434 |             ; vmovq Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 434 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:434:42
[INFO] [stdout]     |
[INFO] [stdout] 434 |             ; vmovq Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 434 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:461:32
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 0b11111101u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11111101u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:462:32
[INFO] [stdout]     |
[INFO] [stdout] 462 |             ; vcomiss xmm1, Rx(reg(rhs_reg)) // compare lhs.upper and rhs.lower
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 462 |             ; vcomiss xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))) // compare lhs.upper and rhs.lower
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:467:32
[INFO] [stdout]     |
[INFO] [stdout] 467 |             ; vpshufd xmm1, Rx(reg(rhs_reg)), 0b11111101u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 467 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b11111101u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:468:32
[INFO] [stdout]     |
[INFO] [stdout] 468 |             ; vcomiss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 468 |             ; vcomiss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:473:25
[INFO] [stdout]     |
[INFO] [stdout] 473 |             ; vminps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 473 |             ; vminps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:473:61
[INFO] [stdout]     |
[INFO] [stdout] 473 |             ; vminps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 473 |             ; vminps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:480:27
[INFO] [stdout]     |
[INFO] [stdout] 480 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 480 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:480:63
[INFO] [stdout]     |
[INFO] [stdout] 480 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 480 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:481:43
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:482:43
[INFO] [stdout]     |
[INFO] [stdout] 482 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 482 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:487:24
[INFO] [stdout]     |
[INFO] [stdout] 487 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:487:42
[INFO] [stdout]     |
[INFO] [stdout] 487 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:494:24
[INFO] [stdout]     |
[INFO] [stdout] 494 |             ; vmovq Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 494 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:494:42
[INFO] [stdout]     |
[INFO] [stdout] 494 |             ; vmovq Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 494 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:529:32
[INFO] [stdout]     |
[INFO] [stdout] 529 |             ; vpshufd xmm1, Rx(reg(arg_reg)), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 529 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(arg_reg))), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:532:33
[INFO] [stdout]     |
[INFO] [stdout] 532 |             ; vcmpgtss xmm3, Rx(reg(arg_reg)), xmm0 // lower > 0.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] 532 |             ; vcmpgtss xmm3, Rx(<u8 as Into<_>>::into(reg(arg_reg))), xmm0 // lower > 0.0
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:541:33
[INFO] [stdout]     |
[INFO] [stdout] 541 |             ; vcmpeqss xmm3, Rx(reg(arg_reg)), xmm0
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 541 |             ; vcmpeqss xmm3, Rx(<u8 as Into<_>>::into(reg(arg_reg))), xmm0
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:556:28
[INFO] [stdout]     |
[INFO] [stdout] 556 |             ; vunpcklps Rx(reg(out_reg)), xmm3, xmm2
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 556 |             ; vunpcklps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm3, xmm2
[INFO] [stdout]     |                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:563:31
[INFO] [stdout]     |
[INFO] [stdout] 563 |             ; movq    rax, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 563 |             ; movq    rax, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:570:30
[INFO] [stdout]     |
[INFO] [stdout] 570 |             ; movq    r8, Rx(reg(rhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 570 |             ; movq    r8, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:577:26
[INFO] [stdout]     |
[INFO] [stdout] 577 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 577 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:577:44
[INFO] [stdout]     |
[INFO] [stdout] 577 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 577 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:579:26
[INFO] [stdout]     |
[INFO] [stdout] 579 |             ; vcomiss Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 579 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(rhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:579:44
[INFO] [stdout]     |
[INFO] [stdout] 579 |             ; vcomiss Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 579 |             ; vcomiss Rx(reg(rhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:608:26
[INFO] [stdout]     |
[INFO] [stdout] 608 |             ; vmovq   Rx(reg(out_reg)), r8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 608 |             ; vmovq   Rx(<u8 as Into<_>>::into(reg(out_reg))), r8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:610:29
[INFO] [stdout]     |
[INFO] [stdout] 610 |             ; vpunpckldq Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 610 |             ; vpunpckldq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:610:65
[INFO] [stdout]     |
[INFO] [stdout] 610 |             ; vpunpckldq Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 610 |             ; vpunpckldq Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:614:27
[INFO] [stdout]     |
[INFO] [stdout] 614 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 614 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:614:63
[INFO] [stdout]     |
[INFO] [stdout] 614 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 614 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:615:43
[INFO] [stdout]     |
[INFO] [stdout] 615 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 615 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:616:43
[INFO] [stdout]     |
[INFO] [stdout] 616 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 616 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:627:31
[INFO] [stdout]     |
[INFO] [stdout] 627 |             ; movq    rax, Rx(reg(arg_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 627 |             ; movq    rax, Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:632:26
[INFO] [stdout]     |
[INFO] [stdout] 632 |             ; vcomiss Rx(reg(arg_reg)), Rx(reg(arg_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 632 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(arg_reg))), Rx(reg(arg_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:632:44
[INFO] [stdout]     |
[INFO] [stdout] 632 |             ; vcomiss Rx(reg(arg_reg)), Rx(reg(arg_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 632 |             ; vcomiss Rx(reg(arg_reg)), Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:650:26
[INFO] [stdout]     |
[INFO] [stdout] 650 |             ; vmovd   Rx(reg(out_reg)), eax
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 650 |             ; vmovd   Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:653:26
[INFO] [stdout]     |
[INFO] [stdout] 653 |             ; addss   Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 653 |             ; addss   Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:655:29
[INFO] [stdout]     |
[INFO] [stdout] 655 |             ; vpunpckldq Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 655 |             ; vpunpckldq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:655:65
[INFO] [stdout]     |
[INFO] [stdout] 655 |             ; vpunpckldq Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 655 |             ; vpunpckldq Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:661:24
[INFO] [stdout]     |
[INFO] [stdout] 661 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg)) // out = 0.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] 661 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg)) // out = 0.0
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:661:60
[INFO] [stdout]     |
[INFO] [stdout] 661 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg)) // out = 0.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] 661 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))) // out = 0.0
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:662:29
[INFO] [stdout]     |
[INFO] [stdout] 662 |             ; vpunpckldq Rx(reg(out_reg)), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 662 |             ; vpunpckldq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:662:47
[INFO] [stdout]     |
[INFO] [stdout] 662 |             ; vpunpckldq Rx(reg(out_reg)), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 662 |             ; vpunpckldq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:674:26
[INFO] [stdout]     |
[INFO] [stdout] 674 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 674 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:674:44
[INFO] [stdout]     |
[INFO] [stdout] 674 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 674 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:676:26
[INFO] [stdout]     |
[INFO] [stdout] 676 |             ; vcomiss Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 676 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(rhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:676:44
[INFO] [stdout]     |
[INFO] [stdout] 676 |             ; vcomiss Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 676 |             ; vcomiss Rx(reg(rhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:683:27
[INFO] [stdout]     |
[INFO] [stdout] 683 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 683 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:683:63
[INFO] [stdout]     |
[INFO] [stdout] 683 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 683 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:684:43
[INFO] [stdout]     |
[INFO] [stdout] 684 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 684 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:685:43
[INFO] [stdout]     |
[INFO] [stdout] 685 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 685 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:693:33
[INFO] [stdout]     |
[INFO] [stdout] 693 |             ; vcmpgtss xmm3, Rx(reg(lhs_reg)), xmm1 // lower > 0.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] 693 |             ; vcmpgtss xmm3, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1 // lower > 0.0
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:694:32
[INFO] [stdout]     |
[INFO] [stdout] 694 |             ; vpshufd xmm2, Rx(reg(lhs_reg)), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 694 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:701:24
[INFO] [stdout]     |
[INFO] [stdout] 701 |             ; vmovq Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 701 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:701:42
[INFO] [stdout]     |
[INFO] [stdout] 701 |             ; vmovq Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 701 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:708:33
[INFO] [stdout]     |
[INFO] [stdout] 708 |             ; vcmpeqss xmm3, Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; vcmpeqss xmm3, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:709:32
[INFO] [stdout]     |
[INFO] [stdout] 709 |             ; vpshufd xmm2, Rx(reg(lhs_reg)), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 709 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:716:24
[INFO] [stdout]     |
[INFO] [stdout] 716 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 716 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:716:42
[INFO] [stdout]     |
[INFO] [stdout] 716 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 716 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:724:32
[INFO] [stdout]     |
[INFO] [stdout] 724 |             ; vpshufd xmm2, Rx(reg(rhs_reg)), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 724 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:726:31
[INFO] [stdout]     |
[INFO] [stdout] 726 |             ; vminss xmm1, Rx(reg(rhs_reg)), xmm1 // xmm1 = min(rhs.lower, 0.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] 726 |             ; vminss xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), xmm1 // xmm1 = min(rhs.lower, 0.0)
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:727:28
[INFO] [stdout]     |
[INFO] [stdout] 727 |             ; vunpcklps Rx(reg(out_reg)), xmm1, xmm2
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 727 |             ; vunpcklps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, xmm2
[INFO] [stdout]     |                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:738:26
[INFO] [stdout]     |
[INFO] [stdout] 738 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 738 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:738:44
[INFO] [stdout]     |
[INFO] [stdout] 738 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 738 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:740:26
[INFO] [stdout]     |
[INFO] [stdout] 740 |             ; vcomiss Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 740 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(rhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:740:44
[INFO] [stdout]     |
[INFO] [stdout] 740 |             ; vcomiss Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 740 |             ; vcomiss Rx(reg(rhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:747:27
[INFO] [stdout]     |
[INFO] [stdout] 747 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 747 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:747:63
[INFO] [stdout]     |
[INFO] [stdout] 747 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 747 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:748:43
[INFO] [stdout]     |
[INFO] [stdout] 748 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 748 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:749:43
[INFO] [stdout]     |
[INFO] [stdout] 749 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 749 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:756:33
[INFO] [stdout]     |
[INFO] [stdout] 756 |             ; vcmpgtss xmm3, Rx(reg(lhs_reg)), xmm1 // lower > 0.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] 756 |             ; vcmpgtss xmm3, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1 // lower > 0.0
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:757:32
[INFO] [stdout]     |
[INFO] [stdout] 757 |             ; vpshufd xmm2, Rx(reg(lhs_reg)), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 757 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:764:24
[INFO] [stdout]     |
[INFO] [stdout] 764 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 764 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:764:42
[INFO] [stdout]     |
[INFO] [stdout] 764 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 764 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:771:33
[INFO] [stdout]     |
[INFO] [stdout] 771 |             ; vcmpeqss xmm3, Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 771 |             ; vcmpeqss xmm3, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:772:32
[INFO] [stdout]     |
[INFO] [stdout] 772 |             ; vpshufd xmm2, Rx(reg(lhs_reg)), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 772 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:779:24
[INFO] [stdout]     |
[INFO] [stdout] 779 |             ; vmovq Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 779 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:779:42
[INFO] [stdout]     |
[INFO] [stdout] 779 |             ; vmovq Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 779 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:787:32
[INFO] [stdout]     |
[INFO] [stdout] 787 |             ; vpshufd xmm2, Rx(reg(lhs_reg)), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 787 |             ; vpshufd xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11111101u8 as i8 // lhs.upper
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:788:32
[INFO] [stdout]     |
[INFO] [stdout] 788 |             ; vpshufd xmm1, Rx(reg(rhs_reg)), 0b11111101u8 as i8 // rhs.upper
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 788 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b11111101u8 as i8 // rhs.upper
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:790:49
[INFO] [stdout]     |
[INFO] [stdout] 790 |             ; vminss xmm2, Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 790 |             ; vminss xmm2, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:791:28
[INFO] [stdout]     |
[INFO] [stdout] 791 |             ; vunpcklps Rx(reg(out_reg)), xmm2, xmm1
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 791 |             ; vunpcklps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2, xmm1
[INFO] [stdout]     |                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:812:32
[INFO] [stdout]     |
[INFO] [stdout] 812 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 0b11111101u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 812 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11111101u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:813:32
[INFO] [stdout]     |
[INFO] [stdout] 813 |             ; vcomiss xmm1, Rx(reg(rhs_reg)) // compare lhs.upper and rhs.lower
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 813 |             ; vcomiss xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))) // compare lhs.upper and rhs.lower
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:818:32
[INFO] [stdout]     |
[INFO] [stdout] 818 |             ; vpshufd xmm1, Rx(reg(rhs_reg)), 0b11111101u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 818 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b11111101u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:819:32
[INFO] [stdout]     |
[INFO] [stdout] 819 |             ; vcomiss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 819 |             ; vcomiss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:825:26
[INFO] [stdout]     |
[INFO] [stdout] 825 |             ; vpinsrd Rx(reg(out_reg)), Rx(reg(out_reg)), eax, 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] 825 |             ; vpinsrd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), eax, 0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:827:26
[INFO] [stdout]     |
[INFO] [stdout] 827 |             ; vpinsrd Rx(reg(out_reg)), Rx(reg(out_reg)), eax, 1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 827 |             ; vpinsrd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), eax, 1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:832:27
[INFO] [stdout]     |
[INFO] [stdout] 832 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 832 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:832:63
[INFO] [stdout]     |
[INFO] [stdout] 832 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 832 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:833:43
[INFO] [stdout]     |
[INFO] [stdout] 833 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 833 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:834:43
[INFO] [stdout]     |
[INFO] [stdout] 834 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 834 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:841:31
[INFO] [stdout]     |
[INFO] [stdout] 841 |             ; vbroadcastss Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 841 |             ; vbroadcastss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:848:31
[INFO] [stdout]     |
[INFO] [stdout] 848 |             ; vbroadcastss Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 848 |             ; vbroadcastss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:859:24
[INFO] [stdout]     |
[INFO] [stdout] 859 |             ; vmovd Rx(IMM_REG), eax
[INFO] [stdout]     |                        ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 859 |             ; vmovd Rx(<u8 as Into<_>>::into(IMM_REG)), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:860:31
[INFO] [stdout]     |
[INFO] [stdout] 860 |             ; vbroadcastss Rx(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                               ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 860 |             ; vbroadcastss Rx(<u8 as Into<_>>::into(IMM_REG)), Rx(IMM_REG)
[INFO] [stdout]     |                               ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:860:44
[INFO] [stdout]     |
[INFO] [stdout] 860 |             ; vbroadcastss Rx(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                                            ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 860 |             ; vbroadcastss Rx(IMM_REG), Rx(<u8 as Into<_>>::into(IMM_REG))
[INFO] [stdout]     |                                            ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:924:30
[INFO] [stdout]     |
[INFO] [stdout] 924 |             ; vmovq xmm0, Rx(reg(arg_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 924 |             ; vmovq xmm0, Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:949:24
[INFO] [stdout]     |
[INFO] [stdout] 949 |             ; vmovq Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 949 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:988:30
[INFO] [stdout]     |
[INFO] [stdout] 988 |             ; vmovq xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 988 |             ; vmovq xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:989:30
[INFO] [stdout]     |
[INFO] [stdout] 989 |             ; vmovq xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; vmovq xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/x86_64/interval.rs:1014:24
[INFO] [stdout]      |
[INFO] [stdout] 1014 |             ; vmovq Rx(reg(out_reg)), xmm0
[INFO] [stdout]      |                        ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1014 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]      |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/point.rs:72:25
[INFO] [stdout]    |
[INFO] [stdout] 72 |             ; vmovss Rx(reg(dst_reg)), [rsp + 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] 72 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(dst_reg))), [rsp + sp_offset]
[INFO] [stdout]    |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/point.rs:82:44
[INFO] [stdout]    |
[INFO] [stdout] 82 |             ; vmovss [rsp + sp_offset], Rx(reg(src_reg))
[INFO] [stdout]    |                                            ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 |             ; vmovss [rsp + sp_offset], Rx(<u8 as Into<_>>::into(reg(src_reg)))
[INFO] [stdout]    |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/point.rs:89:25
[INFO] [stdout]    |
[INFO] [stdout] 89 |             ; vmovss Rx(reg(out_reg)), [rdi + pos]
[INFO] [stdout]    |                         ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), [rdi + pos]
[INFO] [stdout]    |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/point.rs:95:38
[INFO] [stdout]    |
[INFO] [stdout] 95 |             ; vmovss [rcx + pos], Rx(reg(arg_reg))
[INFO] [stdout]    |                                      ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 |             ; vmovss [rcx + pos], Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]    |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:100:25
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:100:61
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:157:25
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:157:49
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:165:25
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vandps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vandps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:165:49
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vandps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vandps Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:171:24
[INFO] [stdout]     |
[INFO] [stdout] 171 |             ; divss Rx(reg(imm)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 |             ; divss Rx(<u8 as Into<_>>::into(reg(imm))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:171:38
[INFO] [stdout]     |
[INFO] [stdout] 171 |             ; divss Rx(reg(imm)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 |             ; divss Rx(reg(imm)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:172:24
[INFO] [stdout]     |
[INFO] [stdout] 172 |             ; movss Rx(reg(out_reg)), Rx(reg(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] 172 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(imm))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:172:42
[INFO] [stdout]     |
[INFO] [stdout] 172 |             ; movss Rx(reg(out_reg)), Rx(reg(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] 172 |             ; movss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(imm)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:177:25
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; sqrtss Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; sqrtss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:177:43
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; sqrtss Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; sqrtss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:182:25
[INFO] [stdout]     |
[INFO] [stdout] 182 |             ; vmulss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 182 |             ; vmulss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:182:61
[INFO] [stdout]     |
[INFO] [stdout] 182 |             ; vmulss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 182 |             ; vmulss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:188:27
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; vroundss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; vroundss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:188:63
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; vroundss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; vroundss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:193:27
[INFO] [stdout]     |
[INFO] [stdout] 193 |             ; vroundss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 |             ; vroundss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:193:63
[INFO] [stdout]     |
[INFO] [stdout] 193 |             ; vroundss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 |             ; vroundss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 2
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:201:38
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vandps  xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vandps  xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:205:25
[INFO] [stdout]     |
[INFO] [stdout] 205 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:205:49
[INFO] [stdout]     |
[INFO] [stdout] 205 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:206:27
[INFO] [stdout]     |
[INFO] [stdout] 206 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 |             ; vroundss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:206:63
[INFO] [stdout]     |
[INFO] [stdout] 206 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 3
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:212:25
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:212:61
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:217:25
[INFO] [stdout]     |
[INFO] [stdout] 217 |             ; vsubss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 |             ; vsubss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:217:61
[INFO] [stdout]     |
[INFO] [stdout] 217 |             ; vsubss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 |             ; vsubss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:222:25
[INFO] [stdout]     |
[INFO] [stdout] 222 |             ; vmulss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 |             ; vmulss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:222:61
[INFO] [stdout]     |
[INFO] [stdout] 222 |             ; vmulss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 |             ; vmulss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:227:25
[INFO] [stdout]     |
[INFO] [stdout] 227 |             ; vdivss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 227 |             ; vdivss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:227:61
[INFO] [stdout]     |
[INFO] [stdout] 227 |             ; vdivss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 227 |             ; vdivss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:238:26
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:238:44
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:245:25
[INFO] [stdout]     |
[INFO] [stdout] 245 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 245 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:245:61
[INFO] [stdout]     |
[INFO] [stdout] 245 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 245 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:253:25
[INFO] [stdout]     |
[INFO] [stdout] 253 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:253:61
[INFO] [stdout]     |
[INFO] [stdout] 253 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:257:25
[INFO] [stdout]     |
[INFO] [stdout] 257 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:257:61
[INFO] [stdout]     |
[INFO] [stdout] 257 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:263:25
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:263:61
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:274:26
[INFO] [stdout]     |
[INFO] [stdout] 274 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 274 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:274:44
[INFO] [stdout]     |
[INFO] [stdout] 274 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 274 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:281:25
[INFO] [stdout]     |
[INFO] [stdout] 281 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 281 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:281:61
[INFO] [stdout]     |
[INFO] [stdout] 281 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 281 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:287:25
[INFO] [stdout]     |
[INFO] [stdout] 287 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:287:61
[INFO] [stdout]     |
[INFO] [stdout] 287 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:291:25
[INFO] [stdout]     |
[INFO] [stdout] 291 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 291 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:291:61
[INFO] [stdout]     |
[INFO] [stdout] 291 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 291 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:297:25
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:297:61
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:315:39
[INFO] [stdout]     |
[INFO] [stdout] 315 |             ; vcmpeqss xmm1, xmm1, Rx(reg(arg_reg))
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 315 |             ; vcmpeqss xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:317:24
[INFO] [stdout]     |
[INFO] [stdout] 317 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 317 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:318:25
[INFO] [stdout]     |
[INFO] [stdout] 318 |             ; vandpd Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 318 |             ; vandpd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:318:43
[INFO] [stdout]     |
[INFO] [stdout] 318 |             ; vandpd Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 318 |             ; vandpd Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:324:31
[INFO] [stdout]     |
[INFO] [stdout] 324 |             ; movq    rax, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 324 |             ; movq    rax, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:339:26
[INFO] [stdout]     |
[INFO] [stdout] 339 |             ; vmovd   Rx(reg(out_reg)), eax
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 339 |             ; vmovd   Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:342:26
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; addss   Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; addss   Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:348:32
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vmovaps xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vmovaps xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:350:33
[INFO] [stdout]     |
[INFO] [stdout] 350 |             ; vucomiss xmm2, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 350 |             ; vucomiss xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:355:32
[INFO] [stdout]     |
[INFO] [stdout] 355 |             ; vmovaps xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 355 |             ; vmovaps xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:363:25
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; movaps Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; movaps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:370:32
[INFO] [stdout]     |
[INFO] [stdout] 370 |             ; vmovaps xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 370 |             ; vmovaps xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:372:33
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vucomiss xmm2, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vucomiss xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:377:32
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovaps xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovaps xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:384:25
[INFO] [stdout]     |
[INFO] [stdout] 384 |             ; movaps Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 384 |             ; movaps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:390:26
[INFO] [stdout]     |
[INFO] [stdout] 390 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 390 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:390:44
[INFO] [stdout]     |
[INFO] [stdout] 390 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 390 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:397:24
[INFO] [stdout]     |
[INFO] [stdout] 397 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 397 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:402:24
[INFO] [stdout]     |
[INFO] [stdout] 402 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:407:25
[INFO] [stdout]     |
[INFO] [stdout] 407 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 407 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:407:61
[INFO] [stdout]     |
[INFO] [stdout] 407 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 407 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:412:24
[INFO] [stdout]     |
[INFO] [stdout] 412 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:422:31
[INFO] [stdout]     |
[INFO] [stdout] 422 |             ; movq    rax, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 422 |             ; movq    rax, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:423:30
[INFO] [stdout]     |
[INFO] [stdout] 423 |             ; movq    r8, Rx(reg(rhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 423 |             ; movq    r8, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:449:26
[INFO] [stdout]     |
[INFO] [stdout] 449 |             ; vmovq   Rx(reg(out_reg)), r8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 449 |             ; vmovq   Rx(<u8 as Into<_>>::into(reg(out_reg))), r8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:456:24
[INFO] [stdout]     |
[INFO] [stdout] 456 |             ; vmovd Rx(IMM_REG), eax
[INFO] [stdout]     |                        ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 456 |             ; vmovd Rx(<u8 as Into<_>>::into(IMM_REG)), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:517:30
[INFO] [stdout]     |
[INFO] [stdout] 517 |             ; movss xmm0, Rx(reg(arg_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 517 |             ; movss xmm0, Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:541:24
[INFO] [stdout]     |
[INFO] [stdout] 541 |             ; movss Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 541 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:577:30
[INFO] [stdout]     |
[INFO] [stdout] 577 |             ; movss xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 577 |             ; movss xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:578:30
[INFO] [stdout]     |
[INFO] [stdout] 578 |             ; movss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 578 |             ; movss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/point.rs:602:24
[INFO] [stdout]     |
[INFO] [stdout] 602 |             ; movss Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 602 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `fidget-jit` (lib) due to 496 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/float_slice.rs:90:26
[INFO] [stdout]    |
[INFO] [stdout] 90 |             ; vmovups Ry(reg(dst_reg)), [rsp + 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] 90 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(dst_reg))), [rsp + sp_offset]
[INFO] [stdout]    |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:100:45
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; vmovups [rsp + sp_offset], Ry(reg(src_reg))
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; vmovups [rsp + sp_offset], Ry(<u8 as Into<_>>::into(reg(src_reg)))
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:108:26
[INFO] [stdout]     |
[INFO] [stdout] 108 |             ; vmovups Ry(reg(out_reg)), [r8 + rcx] // offset by array
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 108 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(out_reg))), [r8 + rcx] // offset by array
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:116:38
[INFO] [stdout]     |
[INFO] [stdout] 116 |             ; vmovups [r8 + rcx], Ry(reg(arg_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 |             ; vmovups [r8 + rcx], Ry(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:190:26
[INFO] [stdout]     |
[INFO] [stdout] 190 |             ; vpaddd  Ry(reg(out_reg)), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 190 |             ; vpaddd  Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:190:50
[INFO] [stdout]     |
[INFO] [stdout] 190 |             ; vpaddd  Ry(reg(out_reg)), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 190 |             ; vpaddd  Ry(reg(out_reg)), ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                  ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:197:26
[INFO] [stdout]     |
[INFO] [stdout] 197 |             ; vpmulld Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |             ; vpmulld Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:201:26
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vpaddd  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vpaddd  Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:201:44
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vpaddd  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 |             ; vpaddd  Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:203:32
[INFO] [stdout]     |
[INFO] [stdout] 203 |             ; vpsrld  ymm2, Ry(reg(out_reg)), 28
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 |             ; vpsrld  ymm2, Ry(<u8 as Into<_>>::into(reg(out_reg))), 28
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:209:38
[INFO] [stdout]     |
[INFO] [stdout] 209 |             ; vpxor   ymm3, ymm3, Ry(reg(out_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 |             ; vpxor   ymm3, ymm3, Ry(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:217:26
[INFO] [stdout]     |
[INFO] [stdout] 217 |             ; vpxor   Ry(reg(out_reg)), ymm1, ymm3
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 |             ; vpxor   Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, ymm3
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:232:26
[INFO] [stdout]     |
[INFO] [stdout] 232 |             ; vpmulld Ry(reg(out_reg)), Ry(reg(arg_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 232 |             ; vpmulld Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(arg_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:238:26
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vpaddd  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vpaddd  Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:238:44
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vpaddd  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vpaddd  Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:241:32
[INFO] [stdout]     |
[INFO] [stdout] 241 |             ; vpsrld  ymm1, Ry(reg(out_reg)), 28
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 |             ; vpsrld  ymm1, Ry(<u8 as Into<_>>::into(reg(out_reg))), 28
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:249:38
[INFO] [stdout]     |
[INFO] [stdout] 249 |             ; vpxor   ymm2, ymm2, Ry(reg(out_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 |             ; vpxor   ymm2, ymm2, Ry(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:266:26
[INFO] [stdout]     |
[INFO] [stdout] 266 |             ; vpor    Ry(reg(out_reg)), ymm2, ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 266 |             ; vpor    Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm2, ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:272:26
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vaddps  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vaddps  Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:272:44
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vaddps  Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vaddps  Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:283:26
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vmovups Ry(reg(out_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:283:44
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vmovups Ry(reg(out_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vmovups Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:290:24
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vpxor Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vpxor Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:290:48
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vpxor Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vpxor Ry(reg(out_reg)), ymm0, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:297:24
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vpand Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vpand Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:297:48
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vpand Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 |             ; vpand Ry(reg(out_reg)), ymm0, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:306:25
[INFO] [stdout]     |
[INFO] [stdout] 306 |             ; vdivps Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 306 |             ; vdivps Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:306:49
[INFO] [stdout]     |
[INFO] [stdout] 306 |             ; vdivps Ry(reg(out_reg)), ymm0, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 306 |             ; vdivps Ry(reg(out_reg)), ymm0, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:311:26
[INFO] [stdout]     |
[INFO] [stdout] 311 |             ; vsqrtps Ry(reg(out_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 311 |             ; vsqrtps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:311:44
[INFO] [stdout]     |
[INFO] [stdout] 311 |             ; vsqrtps Ry(reg(out_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 311 |             ; vsqrtps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:316:25
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vmulps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:316:61
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:322:27
[INFO] [stdout]     |
[INFO] [stdout] 322 |             ; vroundps Ry(reg(out_reg)), Ry(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 322 |             ; vroundps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:322:45
[INFO] [stdout]     |
[INFO] [stdout] 322 |             ; vroundps Ry(reg(out_reg)), Ry(reg(lhs_reg)), 1
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 322 |             ; vroundps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:327:27
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vroundps Ry(reg(out_reg)), Ry(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vroundps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:327:45
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vroundps Ry(reg(out_reg)), Ry(reg(lhs_reg)), 2
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vroundps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg))), 2
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:336:38
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vandps  ymm1, ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vandps  ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:341:25
[INFO] [stdout]     |
[INFO] [stdout] 341 |             ; vaddps Ry(reg(out_reg)), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 341 |             ; vaddps Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:341:49
[INFO] [stdout]     |
[INFO] [stdout] 341 |             ; vaddps Ry(reg(out_reg)), ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 341 |             ; vaddps Ry(reg(out_reg)), ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:342:27
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; vroundps Ry(reg(out_reg)), Ry(reg(out_reg)), 3
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; vroundps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), 3
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:342:45
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; vroundps Ry(reg(out_reg)), Ry(reg(out_reg)), 3
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 |             ; vroundps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), 3
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:348:25
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vaddps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vaddps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:348:61
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vaddps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; vaddps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:353:25
[INFO] [stdout]     |
[INFO] [stdout] 353 |             ; vsubps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 353 |             ; vsubps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:353:61
[INFO] [stdout]     |
[INFO] [stdout] 353 |             ; vsubps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 353 |             ; vsubps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:358:25
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vmulps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:358:61
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vmulps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:363:25
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vdivps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vdivps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:363:61
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vdivps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vdivps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:375:54
[INFO] [stdout]     |
[INFO] [stdout] 375 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:376:54
[INFO] [stdout]     |
[INFO] [stdout] 376 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 376 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:380:25
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; vmaxps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; vmaxps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:380:61
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; vmaxps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; vmaxps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:383:24
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vorps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:383:42
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 |             ; vorps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:389:54
[INFO] [stdout]     |
[INFO] [stdout] 389 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 389 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:390:54
[INFO] [stdout]     |
[INFO] [stdout] 390 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 390 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:394:25
[INFO] [stdout]     |
[INFO] [stdout] 394 |             ; vminps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 394 |             ; vminps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:394:61
[INFO] [stdout]     |
[INFO] [stdout] 394 |             ; vminps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 394 |             ; vminps Ry(reg(out_reg)), Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:399:24
[INFO] [stdout]     |
[INFO] [stdout] 399 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 399 |             ; vorps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:399:42
[INFO] [stdout]     |
[INFO] [stdout] 399 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 399 |             ; vorps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:411:39
[INFO] [stdout]     |
[INFO] [stdout] 411 |             ; vcmpeqps ymm1, ymm1, Ry(reg(arg_reg))
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 |             ; vcmpeqps ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:413:24
[INFO] [stdout]     |
[INFO] [stdout] 413 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 413 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:414:31
[INFO] [stdout]     |
[INFO] [stdout] 414 |             ; vbroadcastss Ry(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 414 |             ; vbroadcastss Ry(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:414:49
[INFO] [stdout]     |
[INFO] [stdout] 414 |             ; vbroadcastss Ry(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 414 |             ; vbroadcastss Ry(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:415:25
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:415:43
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:422:39
[INFO] [stdout]     |
[INFO] [stdout] 422 |             ; vcmpeqps ymm1, ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 422 |             ; vcmpeqps ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:426:37
[INFO] [stdout]     |
[INFO] [stdout] 426 |             ; vandpd ymm1, ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 426 |             ; vandpd ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:427:37
[INFO] [stdout]     |
[INFO] [stdout] 427 |             ; vandpd ymm2, ymm2, Ry(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 427 |             ; vandpd ymm2, ymm2, Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:428:24
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; vorpd Ry(reg(out_reg)), ymm1, ymm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; vorpd Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, ymm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:435:39
[INFO] [stdout]     |
[INFO] [stdout] 435 |             ; vcmpeqps ymm1, ymm1, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 435 |             ; vcmpeqps ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:439:37
[INFO] [stdout]     |
[INFO] [stdout] 439 |             ; vandpd ymm1, ymm1, Ry(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 439 |             ; vandpd ymm1, ymm1, Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:440:37
[INFO] [stdout]     |
[INFO] [stdout] 440 |             ; vandpd ymm2, ymm2, Ry(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 440 |             ; vandpd ymm2, ymm2, Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:441:24
[INFO] [stdout]     |
[INFO] [stdout] 441 |             ; vorpd Ry(reg(out_reg)), ymm1, ymm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 441 |             ; vorpd Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1, ymm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:448:54
[INFO] [stdout]     |
[INFO] [stdout] 448 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(reg(lhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 448 |             ; vcmpunordps ymm1, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:449:54
[INFO] [stdout]     |
[INFO] [stdout] 449 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 449 |             ; vcmpunordps ymm2, Ry(reg(rhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:453:51
[INFO] [stdout]     |
[INFO] [stdout] 453 |             ; vcmpltps ymm2, Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 453 |             ; vcmpltps ymm2, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                   ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:456:51
[INFO] [stdout]     |
[INFO] [stdout] 456 |             ; vcmpgtps ymm3, Ry(reg(lhs_reg)), Ry(reg(rhs_reg))
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 456 |             ; vcmpgtps ymm3, Ry(reg(lhs_reg)), Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                   ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:460:24
[INFO] [stdout]     |
[INFO] [stdout] 460 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 460 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:461:31
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vbroadcastss Ry(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vbroadcastss Ry(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:461:49
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vbroadcastss Ry(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 |             ; vbroadcastss Ry(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:464:25
[INFO] [stdout]     |
[INFO] [stdout] 464 |             ; vandps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 464 |             ; vandps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:464:43
[INFO] [stdout]     |
[INFO] [stdout] 464 |             ; vandps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 464 |             ; vandps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm2
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:471:24
[INFO] [stdout]     |
[INFO] [stdout] 471 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 |             ; vorps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:471:42
[INFO] [stdout]     |
[INFO] [stdout] 471 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm2
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 |             ; vorps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm2
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:474:24
[INFO] [stdout]     |
[INFO] [stdout] 474 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 474 |             ; vorps Ry(<u8 as Into<_>>::into(reg(out_reg))), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:474:42
[INFO] [stdout]     |
[INFO] [stdout] 474 |             ; vorps Ry(reg(out_reg)), Ry(reg(out_reg)), ymm1
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 474 |             ; vorps Ry(reg(out_reg)), Ry(<u8 as Into<_>>::into(reg(out_reg))), ymm1
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:480:24
[INFO] [stdout]     |
[INFO] [stdout] 480 |             ; vmovd Rx(IMM_REG), eax
[INFO] [stdout]     |                        ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 480 |             ; vmovd Rx(<u8 as Into<_>>::into(IMM_REG)), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:481:31
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vbroadcastss Ry(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                               ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vbroadcastss Ry(<u8 as Into<_>>::into(IMM_REG)), Rx(IMM_REG)
[INFO] [stdout]     |                               ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:481:44
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vbroadcastss Ry(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                                            ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 |             ; vbroadcastss Ry(IMM_REG), Rx(<u8 as Into<_>>::into(IMM_REG))
[INFO] [stdout]     |                                            ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:531:41
[INFO] [stdout]     |
[INFO] [stdout] 531 |             ; vmovups [rsp + 0x180], Ry(reg(arg_reg))
[INFO] [stdout]     |                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 531 |             ; vmovups [rsp + 0x180], Ry(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:573:26
[INFO] [stdout]     |
[INFO] [stdout] 573 |             ; vmovups Ry(reg(out_reg)), [rsp + 0x180]
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 573 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(out_reg))), [rsp + 0x180]
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:617:41
[INFO] [stdout]     |
[INFO] [stdout] 617 |             ; vmovups [rsp + 0x180], Ry(reg(lhs_reg))
[INFO] [stdout]     |                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 617 |             ; vmovups [rsp + 0x180], Ry(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:618:41
[INFO] [stdout]     |
[INFO] [stdout] 618 |             ; vmovups [rsp + 0x200], Ry(reg(rhs_reg))
[INFO] [stdout]     |                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 618 |             ; vmovups [rsp + 0x200], Ry(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/float_slice.rs:668:26
[INFO] [stdout]     |
[INFO] [stdout] 668 |             ; vmovups Ry(reg(out_reg)), [rsp + 0x180]
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 668 |             ; vmovups Ry(<u8 as Into<_>>::into(reg(out_reg))), [rsp + 0x180]
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/grad_slice.rs:79:26
[INFO] [stdout]    |
[INFO] [stdout] 79 |             ; vmovups Rx(reg(dst_reg)), [rsp + 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] 79 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(dst_reg))), [rsp + sp_offset]
[INFO] [stdout]    |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/grad_slice.rs:89:45
[INFO] [stdout]    |
[INFO] [stdout] 89 |             ; vmovups [rsp + sp_offset], Rx(reg(src_reg))
[INFO] [stdout]    |                                             ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 |             ; vmovups [rsp + sp_offset], Rx(<u8 as Into<_>>::into(reg(src_reg)))
[INFO] [stdout]    |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/grad_slice.rs:96:26
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; vmovups Rx(reg(out_reg)), [r8 + rcx] // offset by array
[INFO] [stdout]    |                          ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), [r8 + rcx] // offset by array
[INFO] [stdout]    |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:104:38
[INFO] [stdout]     |
[INFO] [stdout] 104 |             ; vmovups [r8 + rcx], Rx(reg(arg_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 |             ; vmovups [r8 + rcx], Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:158:26
[INFO] [stdout]     |
[INFO] [stdout] 158 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:158:44
[INFO] [stdout]     |
[INFO] [stdout] 158 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:165:24
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:165:48
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:173:26
[INFO] [stdout]     |
[INFO] [stdout] 173 |             ; vcomiss Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:177:26
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:177:44
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:183:24
[INFO] [stdout]     |
[INFO] [stdout] 183 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:183:48
[INFO] [stdout]     |
[INFO] [stdout] 183 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 |             ; vpxor Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:194:30
[INFO] [stdout]     |
[INFO] [stdout] 194 |             ; movss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 194 |             ; movss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:206:31
[INFO] [stdout]     |
[INFO] [stdout] 206 |             ; vdivps xmm0, Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 |             ; vdivps xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:211:30
[INFO] [stdout]     |
[INFO] [stdout] 211 |             ; divss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 |             ; divss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:213:26
[INFO] [stdout]     |
[INFO] [stdout] 213 |             ; vmovups Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:214:24
[INFO] [stdout]     |
[INFO] [stdout] 214 |             ; movss Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:221:38
[INFO] [stdout]     |
[INFO] [stdout] 221 |             ; vsqrtss xmm0, xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 |             ; vsqrtss xmm0, xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:233:31
[INFO] [stdout]     |
[INFO] [stdout] 233 |             ; vdivps xmm0, Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 |             ; vdivps xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:236:38
[INFO] [stdout]     |
[INFO] [stdout] 236 |             ; vsqrtss xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 236 |             ; vsqrtss xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:238:26
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vmovups Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 238 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:239:25
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:239:43
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vmovss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:254:37
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vbroadcastss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vbroadcastss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:256:25
[INFO] [stdout]     |
[INFO] [stdout] 256 |             ; vmulps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 256 |             ; vmulps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:256:49
[INFO] [stdout]     |
[INFO] [stdout] 256 |             ; vmulps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 256 |             ; vmulps Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:262:51
[INFO] [stdout]     |
[INFO] [stdout] 262 |             ; vroundss xmm1, Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 |             ; vroundss xmm1, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                                   ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:263:24
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:263:60
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:264:24
[INFO] [stdout]     |
[INFO] [stdout] 264 |             ; movss Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:269:51
[INFO] [stdout]     |
[INFO] [stdout] 269 |             ; vroundss xmm1, Rx(reg(lhs_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 269 |             ; vroundss xmm1, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 2
[INFO] [stdout]     |                                                   ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:270:24
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:270:60
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:271:24
[INFO] [stdout]     |
[INFO] [stdout] 271 |             ; movss Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 |             ; movss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:279:38
[INFO] [stdout]     |
[INFO] [stdout] 279 |             ; vandps  xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 279 |             ; vandps  xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:283:25
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:283:49
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 |             ; vaddss Rx(reg(out_reg)), xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:284:27
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vroundss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:284:63
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg)), 3
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vroundss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 3
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:290:25
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vaddps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:290:61
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vaddps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:295:25
[INFO] [stdout]     |
[INFO] [stdout] 295 |             ; vsubps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 |             ; vsubps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:295:61
[INFO] [stdout]     |
[INFO] [stdout] 295 |             ; vsubps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 |             ; vsubps Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:301:37
[INFO] [stdout]     |
[INFO] [stdout] 301 |             ; vbroadcastss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 301 |             ; vbroadcastss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:302:37
[INFO] [stdout]     |
[INFO] [stdout] 302 |             ; vmulps xmm1, xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 302 |             ; vmulps xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:303:37
[INFO] [stdout]     |
[INFO] [stdout] 303 |             ; vbroadcastss xmm2, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 303 |             ; vbroadcastss xmm2, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:304:37
[INFO] [stdout]     |
[INFO] [stdout] 304 |             ; vmulps xmm2, xmm2, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 304 |             ; vmulps xmm2, xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:307:49
[INFO] [stdout]     |
[INFO] [stdout] 307 |             ; vmulss xmm2, Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 |             ; vmulss xmm2, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:308:26
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ; vmovups Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:309:25
[INFO] [stdout]     |
[INFO] [stdout] 309 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 309 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:309:43
[INFO] [stdout]     |
[INFO] [stdout] 309 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 309 |             ; vmovss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:316:37
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vbroadcastss xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; vbroadcastss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:317:37
[INFO] [stdout]     |
[INFO] [stdout] 317 |             ; vmulps xmm1, xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 317 |             ; vmulps xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:320:37
[INFO] [stdout]     |
[INFO] [stdout] 320 |             ; vbroadcastss xmm2, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 320 |             ; vbroadcastss xmm2, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:321:37
[INFO] [stdout]     |
[INFO] [stdout] 321 |             ; vmulps xmm2, xmm2, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 321 |             ; vmulps xmm2, xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:327:49
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vmulss xmm2, Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 327 |             ; vmulss xmm2, Rx(reg(rhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:334:49
[INFO] [stdout]     |
[INFO] [stdout] 334 |             ; vdivss xmm2, Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 334 |             ; vdivss xmm2, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:335:26
[INFO] [stdout]     |
[INFO] [stdout] 335 |             ; vmovups Rx(reg(out_reg)), xmm1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 335 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:336:25
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vmovss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:336:43
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vmovss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 |             ; vmovss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:349:26
[INFO] [stdout]     |
[INFO] [stdout] 349 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:349:44
[INFO] [stdout]     |
[INFO] [stdout] 349 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:354:26
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vmovups Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:354:44
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vmovups Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:358:24
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:358:60
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 358 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:359:27
[INFO] [stdout]     |
[INFO] [stdout] 359 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 359 |             ; vcmpeqss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:359:63
[INFO] [stdout]     |
[INFO] [stdout] 359 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 359 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:363:26
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:363:44
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:372:26
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:372:44
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:377:26
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:377:44
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovups Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:381:24
[INFO] [stdout]     |
[INFO] [stdout] 381 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 381 |             ; vpxor Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:381:60
[INFO] [stdout]     |
[INFO] [stdout] 381 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 381 |             ; vpxor Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:382:27
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vcmpeqss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:382:63
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 |             ; vcmpeqss Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:386:26
[INFO] [stdout]     |
[INFO] [stdout] 386 |             ; vmovups Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 |             ; vmovups Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:386:44
[INFO] [stdout]     |
[INFO] [stdout] 386 |             ; vmovups Rx(reg(out_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 |             ; vmovups Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:403:33
[INFO] [stdout]     |
[INFO] [stdout] 403 |             ; vcmpeqss xmm1, Rx(reg(arg_reg)), xmm1
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 403 |             ; vcmpeqss xmm1, Rx(<u8 as Into<_>>::into(reg(arg_reg))), xmm1
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:404:25
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; vandps Rx(reg(out_reg)), xmm1, Rx(reg(i))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; vandps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, Rx(reg(i))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:404:49
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; vandps Rx(reg(out_reg)), xmm1, Rx(reg(i))
[INFO] [stdout]     |                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; vandps Rx(reg(out_reg)), xmm1, Rx(<u8 as Into<_>>::into(reg(i)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:410:33
[INFO] [stdout]     |
[INFO] [stdout] 410 |             ; vcmpeqss xmm1, Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 410 |             ; vcmpeqss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:415:37
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 |             ; vandpd xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:416:37
[INFO] [stdout]     |
[INFO] [stdout] 416 |             ; vandpd xmm2, xmm2, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 |             ; vandpd xmm2, xmm2, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:417:24
[INFO] [stdout]     |
[INFO] [stdout] 417 |             ; vorpd Rx(reg(out_reg)), xmm1, xmm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 417 |             ; vorpd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, xmm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:423:33
[INFO] [stdout]     |
[INFO] [stdout] 423 |             ; vcmpeqss xmm1, Rx(reg(lhs_reg)), xmm1
[INFO] [stdout]     |                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 423 |             ; vcmpeqss xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm1
[INFO] [stdout]     |                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:428:37
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; vandpd xmm1, xmm1, Rx(reg(rhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; vandpd xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:429:37
[INFO] [stdout]     |
[INFO] [stdout] 429 |             ; vandpd xmm2, xmm2, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 429 |             ; vandpd xmm2, xmm2, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:430:24
[INFO] [stdout]     |
[INFO] [stdout] 430 |             ; vorpd Rx(reg(out_reg)), xmm1, xmm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 430 |             ; vorpd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, xmm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:437:31
[INFO] [stdout]     |
[INFO] [stdout] 437 |             ; movq    rax, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 437 |             ; movq    rax, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:452:26
[INFO] [stdout]     |
[INFO] [stdout] 452 |             ; vmovd   Rx(reg(out_reg)), eax
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; vmovd   Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:455:26
[INFO] [stdout]     |
[INFO] [stdout] 455 |             ; addss   Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 455 |             ; addss   Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:462:31
[INFO] [stdout]     |
[INFO] [stdout] 462 |             ; movq    rax, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 462 |             ; movq    rax, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:463:30
[INFO] [stdout]     |
[INFO] [stdout] 463 |             ; movq    r8, Rx(reg(rhs_reg))
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 463 |             ; movq    r8, Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:489:26
[INFO] [stdout]     |
[INFO] [stdout] 489 |             ; vmovq   Rx(reg(out_reg)), r8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 489 |             ; vmovq   Rx(<u8 as Into<_>>::into(reg(out_reg))), r8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:495:26
[INFO] [stdout]     |
[INFO] [stdout] 495 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 495 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), Rx(reg(rhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:495:44
[INFO] [stdout]     |
[INFO] [stdout] 495 |             ; vcomiss Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 495 |             ; vcomiss Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:502:24
[INFO] [stdout]     |
[INFO] [stdout] 502 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 502 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:508:24
[INFO] [stdout]     |
[INFO] [stdout] 508 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 508 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:513:25
[INFO] [stdout]     |
[INFO] [stdout] 513 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 513 |             ; vaddss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:513:61
[INFO] [stdout]     |
[INFO] [stdout] 513 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 513 |             ; vaddss Rx(reg(out_reg)), Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:518:24
[INFO] [stdout]     |
[INFO] [stdout] 518 |             ; vmovd Rx(reg(out_reg)), eax
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 518 |             ; vmovd Rx(<u8 as Into<_>>::into(reg(out_reg))), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:528:24
[INFO] [stdout]     |
[INFO] [stdout] 528 |             ; vpxor Rx(IMM_REG), Rx(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                        ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 |             ; vpxor Rx(<u8 as Into<_>>::into(IMM_REG)), Rx(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                        ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:528:50
[INFO] [stdout]     |
[INFO] [stdout] 528 |             ; vpxor Rx(IMM_REG), Rx(IMM_REG), Rx(IMM_REG)
[INFO] [stdout]     |                                                  ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 |             ; vpxor Rx(IMM_REG), Rx(IMM_REG), Rx(<u8 as Into<_>>::into(IMM_REG))
[INFO] [stdout]     |                                                  ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:530:24
[INFO] [stdout]     |
[INFO] [stdout] 530 |             ; vmovd Rx(IMM_REG), eax
[INFO] [stdout]     |                        ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 530 |             ; vmovd Rx(<u8 as Into<_>>::into(IMM_REG)), eax
[INFO] [stdout]     |                        ++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:578:49
[INFO] [stdout]     |
[INFO] [stdout] 578 |             ; vmovsd xmm0, Rx(reg(arg_reg)), Rx(reg(arg_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 578 |             ; vmovsd xmm0, Rx(reg(arg_reg)), Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:579:32
[INFO] [stdout]     |
[INFO] [stdout] 579 |             ; vpshufd xmm1, Rx(reg(arg_reg)), 0b1110
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 579 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(arg_reg))), 0b1110
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:604:30
[INFO] [stdout]     |
[INFO] [stdout] 604 |             ; vpunpcklqdq Rx(reg(out_reg)), xmm0, xmm1
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 604 |             ; vpunpcklqdq Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, xmm1
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:640:32
[INFO] [stdout]     |
[INFO] [stdout] 640 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 0b1110
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 640 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b1110
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:641:49
[INFO] [stdout]     |
[INFO] [stdout] 641 |             ; vmovsd xmm2, Rx(reg(rhs_reg)), Rx(reg(rhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 641 |             ; vmovsd xmm2, Rx(reg(rhs_reg)), Rx(<u8 as Into<_>>::into(reg(rhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:642:32
[INFO] [stdout]     |
[INFO] [stdout] 642 |             ; vpshufd xmm3, Rx(reg(rhs_reg)), 0b1110
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 642 |             ; vpshufd xmm3, Rx(<u8 as Into<_>>::into(reg(rhs_reg))), 0b1110
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:643:49
[INFO] [stdout]     |
[INFO] [stdout] 643 |             ; vmovsd xmm0, Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 643 |             ; vmovsd xmm0, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/grad_slice.rs:668:30
[INFO] [stdout]     |
[INFO] [stdout] 668 |             ; vpunpcklqdq Rx(reg(out_reg)), xmm0, xmm1
[INFO] [stdout]     |                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 668 |             ; vpunpcklqdq Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, xmm1
[INFO] [stdout]     |                              ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/interval.rs:73:23
[INFO] [stdout]    |
[INFO] [stdout] 73 |             ; movq Rx(reg(dst_reg)), [rsp + 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] 73 |             ; movq Rx(<u8 as Into<_>>::into(reg(dst_reg))), [rsp + sp_offset]
[INFO] [stdout]    |                       ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/interval.rs:84:42
[INFO] [stdout]    |
[INFO] [stdout] 84 |             ; movq [rsp + sp_offset], Rx(reg(src_reg))
[INFO] [stdout]    |                                          ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |             ; movq [rsp + sp_offset], Rx(<u8 as Into<_>>::into(reg(src_reg)))
[INFO] [stdout]    |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/interval.rs:90:24
[INFO] [stdout]    |
[INFO] [stdout] 90 |             ; vmovq Rx(reg(out_reg)), [rdi + pos]
[INFO] [stdout]    |                        ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 90 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), [rdi + pos]
[INFO] [stdout]    |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x86_64/interval.rs:96:37
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; vmovq [rcx + pos], Rx(reg(arg_reg))
[INFO] [stdout]    |                                     ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; vmovq [rcx + pos], Rx(<u8 as Into<_>>::into(reg(arg_reg)))
[INFO] [stdout]    |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:149:24
[INFO] [stdout]     |
[INFO] [stdout] 149 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:149:42
[INFO] [stdout]     |
[INFO] [stdout] 149 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:154:26
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; vpshufd Rx(reg(out_reg)), Rx(reg(lhs_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:154:44
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; vpshufd Rx(reg(out_reg)), Rx(reg(lhs_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; vpshufd Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 0b11110001u8 as i8
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:157:25
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:157:43
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), Rx(reg(out_reg)), xmm0
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 |             ; vxorps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:167:32
[INFO] [stdout]     |
[INFO] [stdout] 167 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 167 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:174:31
[INFO] [stdout]     |
[INFO] [stdout] 174 |             ; comiss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 174 |             ; comiss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:179:24
[INFO] [stdout]     |
[INFO] [stdout] 179 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:179:42
[INFO] [stdout]     |
[INFO] [stdout] 179 |             ; vmovq Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 |             ; vmovq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:187:37
[INFO] [stdout]     |
[INFO] [stdout] 187 |             ; vxorps xmm0, xmm0, Rx(reg(lhs_reg)) // xor to swap sign bits
[INFO] [stdout]     |                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 |             ; vxorps xmm0, xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg))) // xor to swap sign bits
[INFO] [stdout]     |                                     ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:188:26
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; vpshufd Rx(reg(out_reg)), xmm0, 1 // swap lo and 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] 188 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, 1 // swap lo and hi
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:199:25
[INFO] [stdout]     |
[INFO] [stdout] 199 |             ; vandps Rx(reg(out_reg)), Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 |             ; vandps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:199:43
[INFO] [stdout]     |
[INFO] [stdout] 199 |             ; vandps Rx(reg(out_reg)), Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 |             ; vandps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:202:32
[INFO] [stdout]     |
[INFO] [stdout] 202 |             ; vpshufd xmm0, Rx(reg(out_reg)), 0b11110001u8 as i8
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 202 |             ; vpshufd xmm0, Rx(<u8 as Into<_>>::into(reg(out_reg))), 0b11110001u8 as i8
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:204:32
[INFO] [stdout]     |
[INFO] [stdout] 204 |             ; vcomiss xmm0, Rx(reg(out_reg)) // Compare abs(hi) vs abs(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] 204 |             ; vcomiss xmm0, Rx(<u8 as Into<_>>::into(reg(out_reg))) // Compare abs(hi) vs abs(lo)
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:207:26
[INFO] [stdout]     |
[INFO] [stdout] 207 |             ; vpshufd Rx(reg(out_reg)), Rx(reg(out_reg)), 0b11110011u8 as i8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), 0b11110011u8 as i8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:207:44
[INFO] [stdout]     |
[INFO] [stdout] 207 |             ; vpshufd Rx(reg(out_reg)), Rx(reg(out_reg)), 0b11110011u8 as i8
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 |             ; vpshufd Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 0b11110011u8 as i8
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:212:26
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; vpinsrd Rx(reg(out_reg)), Rx(reg(out_reg)), eax, 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] 212 |             ; vpinsrd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), eax, 0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:222:26
[INFO] [stdout]     |
[INFO] [stdout] 222 |             ; vcomiss Rx(reg(lhs_reg)), xmm0
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 |             ; vcomiss Rx(<u8 as Into<_>>::into(reg(lhs_reg))), xmm0
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:224:32
[INFO] [stdout]     |
[INFO] [stdout] 224 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 1 // extract high element
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 224 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1 // extract high element
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:229:26
[INFO] [stdout]     |
[INFO] [stdout] 229 |             ; pcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 229 |             ; pcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:229:44
[INFO] [stdout]     |
[INFO] [stdout] 229 |             ; pcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 229 |             ; pcmpeqw Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:230:24
[INFO] [stdout]     |
[INFO] [stdout] 230 |             ; pslld Rx(reg(out_reg)), 23
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 |             ; pslld Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:231:24
[INFO] [stdout]     |
[INFO] [stdout] 231 |             ; psrld Rx(reg(out_reg)), 1
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 |             ; psrld Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:239:25
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vdivps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vdivps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:239:49
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vdivps Rx(reg(out_reg)), xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |             ; vdivps Rx(reg(out_reg)), xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:240:25
[INFO] [stdout]     |
[INFO] [stdout] 240 |             ; pshufd Rx(reg(out_reg)), Rx(reg(out_reg)), 0b0001
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 |             ; pshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), 0b0001
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:240:43
[INFO] [stdout]     |
[INFO] [stdout] 240 |             ; pshufd Rx(reg(out_reg)), Rx(reg(out_reg)), 0b0001
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 |             ; pshufd Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 0b0001
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:250:32
[INFO] [stdout]     |
[INFO] [stdout] 250 |             ; vcomiss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 250 |             ; vcomiss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:254:26
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vsqrtps Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vsqrtps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg))
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:254:44
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vsqrtps Rx(reg(out_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 |             ; vsqrtps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                            ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:259:27
[INFO] [stdout]     |
[INFO] [stdout] 259 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 |             ; vpcmpeqw Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:259:63
[INFO] [stdout]     |
[INFO] [stdout] 259 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(reg(out_reg))
[INFO] [stdout]     |                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 |             ; vpcmpeqw Rx(reg(out_reg)), Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg)))
[INFO] [stdout]     |                                                               ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:260:43
[INFO] [stdout]     |
[INFO] [stdout] 260 |             ; vpslld Rx(reg(out_reg)), Rx(reg(out_reg)), 23
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 260 |             ; vpslld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 23
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:261:43
[INFO] [stdout]     |
[INFO] [stdout] 261 |             ; vpsrld Rx(reg(out_reg)), Rx(reg(out_reg)), 1
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 |             ; vpsrld Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 1
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:270:49
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vmulps xmm2, Rx(reg(lhs_reg)), Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 270 |             ; vmulps xmm2, Rx(reg(lhs_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:272:32
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vpshufd xmm1, Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 |             ; vpshufd xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:275:32
[INFO] [stdout]     |
[INFO] [stdout] 275 |             ; vcomiss xmm0, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 |             ; vcomiss xmm0, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:279:24
[INFO] [stdout]     |
[INFO] [stdout] 279 |             ; vmovq Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 279 |             ; vmovq Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                        ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:284:26
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vpshufd Rx(reg(out_reg)), xmm2, 0b11110001u8 as i8
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2, 0b11110001u8 as i8
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:289:26
[INFO] [stdout]     |
[INFO] [stdout] 289 |             ; vpshufd Rx(reg(out_reg)), xmm2, 1
[INFO] [stdout]     |                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 289 |             ; vpshufd Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2, 1
[INFO] [stdout]     |                          ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:290:25
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vmaxss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vmaxss Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:290:43
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vmaxss Rx(reg(out_reg)), Rx(reg(out_reg)), xmm2
[INFO] [stdout]     |                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 290 |             ; vmaxss Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm2
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:292:43
[INFO] [stdout]     |
[INFO] [stdout] 292 |             ; vpsllq Rx(reg(out_reg)), Rx(reg(out_reg)), 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] 292 |             ; vpsllq Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(out_reg))), 32
[INFO] [stdout]     |                                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:300:27
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; vroundps Rx(reg(out_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; vroundps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:300:45
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; vroundps Rx(reg(out_reg)), Rx(reg(lhs_reg)), 1
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; vroundps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 1
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:305:27
[INFO] [stdout]     |
[INFO] [stdout] 305 |             ; vroundps Rx(reg(out_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 305 |             ; vroundps Rx(<u8 as Into<_>>::into(reg(out_reg))), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                           ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:305:45
[INFO] [stdout]     |
[INFO] [stdout] 305 |             ; vroundps Rx(reg(out_reg)), Rx(reg(lhs_reg)), 2
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 305 |             ; vroundps Rx(reg(out_reg)), Rx(<u8 as Into<_>>::into(reg(lhs_reg))), 2
[INFO] [stdout]     |                                             ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:314:38
[INFO] [stdout]     |
[INFO] [stdout] 314 |             ; vandps  xmm1, xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 314 |             ; vandps  xmm1, xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                      ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:319:25
[INFO] [stdout]     |
[INFO] [stdout] 319 |             ; vaddps Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 |             ; vaddps Rx(<u8 as Into<_>>::into(reg(out_reg))), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                         ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x86_64/interval.rs:319:49
[INFO] [stdout]     |
[INFO] [stdout] 319 |             ; vaddps Rx(reg(out_reg)), xmm1, Rx(reg(lhs_reg))
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 |             ; vaddps Rx(reg(out_reg)), xmm1, Rx(<u8 as Into<_>>::into(reg(lhs_reg)))
[INFO] [stdout]     |                                                 ++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[WARN] too many lines in the log, truncating it
