[INFO] fetching crate ranis 0.1.0...
[INFO] checking ranis-0.1.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate ranis 0.1.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate ranis 0.1.0
[INFO] finished tweaking crates.io crate ranis 0.1.0
[INFO] tweaked toml for crates.io crate ranis 0.1.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate ranis 0.1.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate ranis 0.1.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: Cargo.toml: version requirement `0.9.34+deprecated` for dependency `serde_yaml` includes semver metadata which will be ignored, removing the metadata is recommended to avoid confusion
[INFO] [stderr] warning: `ranis` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30
[INFO] running `Command { std: "docker" "start" "3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30", 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" "3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30", 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" "3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: Cargo.toml: version requirement `0.9.34+deprecated` for dependency `serde_yaml` includes semver metadata which will be ignored, removing the metadata is recommended to avoid confusion
[INFO] [stderr] warning: `ranis` (manifest) generated 1 warning
[INFO] [stderr]    Compiling unicode-ident v1.0.24
[INFO] [stderr]    Compiling libc v0.2.189
[INFO] [stderr]     Checking utf8parse v0.2.2
[INFO] [stderr]    Compiling serde_core v1.0.229
[INFO] [stderr]    Compiling serde v1.0.229
[INFO] [stderr]     Checking anstyle v1.0.14
[INFO] [stderr]     Checking rand_core v0.10.1
[INFO] [stderr]     Checking cfg-if v1.0.4
[INFO] [stderr]     Checking anstyle-query v1.1.5
[INFO] [stderr]     Checking is_terminal_polyfill v1.70.2
[INFO] [stderr]     Checking colorchoice v1.0.5
[INFO] [stderr]    Compiling getrandom v0.4.3
[INFO] [stderr]     Checking strsim v0.11.1
[INFO] [stderr]    Compiling anyhow v1.0.104
[INFO] [stderr]    Compiling thiserror v2.0.20
[INFO] [stderr]    Compiling heck v0.5.0
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]    Compiling lazy_static v1.5.0
[INFO] [stderr]    Compiling byteorder v1.5.0
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]     Checking anstyle-parse v1.0.0
[INFO] [stderr]     Checking clap_lex v1.1.0
[INFO] [stderr]    Compiling bitflags v2.13.1
[INFO] [stderr]     Checking cpufeatures v0.3.1
[INFO] [stderr]     Checking equivalent v1.0.2
[INFO] [stderr]     Checking fnv v1.0.7
[INFO] [stderr]     Checking unsafe-libyaml v0.2.11
[INFO] [stderr]     Checking chacha20 v0.10.2
[INFO] [stderr]     Checking anstream v1.0.0
[INFO] [stderr]     Checking indexmap v2.14.0
[INFO] [stderr]     Checking clap_builder v4.6.6
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling syn v3.0.4
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]    Compiling proc-macro-error-attr3 v3.1.0
[INFO] [stderr]     Checking memmap2 v0.9.11
[INFO] [stderr]     Checking rand v0.10.2
[INFO] [stderr]    Compiling proc-macro-error3 v3.1.0
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling clap_derive v4.6.4
[INFO] [stderr]    Compiling thiserror-impl v2.0.20
[INFO] [stderr]    Compiling dynasm v5.1.0
[INFO] [stderr]     Checking clap v4.6.6
[INFO] [stderr]     Checking serde_yaml v0.9.34+deprecated
[INFO] [stderr]     Checking dynasmrt v5.1.0
[INFO] [stderr]     Checking ranis v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:52:22
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; pop Rq(indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 52 |             ; pop Rq(<u8 as Into<_>>::into(indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:66:45
[INFO] [stdout]    |
[INFO] [stdout] 66 | ...                   ; xor DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |                             ; xor DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:71:45
[INFO] [stdout]    |
[INFO] [stdout] 71 | ...                   ; sub DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 |                             ; sub DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:76:45
[INFO] [stdout]    |
[INFO] [stdout] 76 | ...                   ; add DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 |                             ; add DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:81:45
[INFO] [stdout]    |
[INFO] [stdout] 81 | ...                   ; rol DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) 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] 81 |                             ; rol DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i8
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:86:45
[INFO] [stdout]    |
[INFO] [stdout] 86 | ...                   ; ror DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) 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] 86 |                             ; ror DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i8
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:93:41
[INFO] [stdout]    |
[INFO] [stdout] 93 |                         ; not DWORD [Rq(indexer_register_id) + index]
[INFO] [stdout]    |                                         ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |                         ; not DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index]
[INFO] [stdout]    |                                         ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/schema/x64.rs:106:22
[INFO] [stdout]     |
[INFO] [stdout] 106 |             ; jmp Rq(indexer_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 |             ; jmp Rq(<u8 as Into<_>>::into(indexer_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:50:22
[INFO] [stdout]    |
[INFO] [stdout] 50 |             ; pop Rd(indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 |             ; pop Rd(<u8 as Into<_>>::into(indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:52:22
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; mov Rb(seed_register_id), seed 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] 52 |             ; mov Rb(<u8 as Into<_>>::into(seed_register_id)), seed as i8
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:54:65
[INFO] [stdout]    |
[INFO] [stdout] 54 |             ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(seed_register_id)
[INFO] [stdout]    |                                                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |             ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(<u8 as Into<_>>::into(seed_register_id))
[INFO] [stdout]    |                                                                 ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:54:28
[INFO] [stdout]    |
[INFO] [stdout] 54 |             ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(seed_register_id)
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |             ; xor BYTE [Rd(<u8 as Into<_>>::into(indexer_register_id)) + ecx + 19], Rb(seed_register_id)
[INFO] [stdout]    |                            ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:55:22
[INFO] [stdout]    |
[INFO] [stdout] 55 |             ; add Rb(seed_register_id), BYTE [Rd(indexer_register_id) + ecx + 19]
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 |             ; add Rb(<u8 as Into<_>>::into(seed_register_id)), BYTE [Rd(indexer_register_id) + ecx + 19]
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:55:50
[INFO] [stdout]    |
[INFO] [stdout] 55 |             ; add Rb(seed_register_id), BYTE [Rd(indexer_register_id) + ecx + 19]
[INFO] [stdout]    |                                                  ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 |             ; add Rb(seed_register_id), BYTE [Rd(<u8 as Into<_>>::into(indexer_register_id)) + ecx + 19]
[INFO] [stdout]    |                                                  ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:47:22
[INFO] [stdout]    |
[INFO] [stdout] 47 |             ; mov Rb(seed_register_id), seed 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] 47 |             ; mov Rb(<u8 as Into<_>>::into(seed_register_id)), seed as i8
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:49:22
[INFO] [stdout]    |
[INFO] [stdout] 49 |             ; lea Rq(indexer_register_id), [>data - 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] 49 |             ; lea Rq(<u8 as Into<_>>::into(indexer_register_id)), [>data - 1]
[INFO] [stdout]    |                      ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:51:60
[INFO] [stdout]    |
[INFO] [stdout] 51 |             ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(seed_register_id)
[INFO] [stdout]    |                                                            ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 |             ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(<u8 as Into<_>>::into(seed_register_id))
[INFO] [stdout]    |                                                            ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:51:28
[INFO] [stdout]    |
[INFO] [stdout] 51 |             ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(seed_register_id)
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 |             ; xor BYTE [Rq(<u8 as Into<_>>::into(indexer_register_id)) + rcx], Rb(seed_register_id)
[INFO] [stdout]    |                            ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:52:22
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; add Rb(seed_register_id), BYTE [Rq(indexer_register_id) + rcx]
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; add Rb(<u8 as Into<_>>::into(seed_register_id)), BYTE [Rq(indexer_register_id) + rcx]
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:52:50
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; add Rb(seed_register_id), BYTE [Rq(indexer_register_id) + rcx]
[INFO] [stdout]    |                                                  ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; add Rb(seed_register_id), BYTE [Rq(<u8 as Into<_>>::into(indexer_register_id)) + rcx]
[INFO] [stdout]    |                                                  ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x64_arch/garbage.rs:76:22
[INFO] [stdout]    |
[INFO] [stdout] 76 |             ; rol Rq(register_id), 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] 76 |             ; rol Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]    |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x64_arch/garbage.rs:84:22
[INFO] [stdout]    |
[INFO] [stdout] 84 |             ; ror Rq(register_id), 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] 84 |             ; ror Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]    |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x64_arch/garbage.rs:92:22
[INFO] [stdout]    |
[INFO] [stdout] 92 |             ; shl Rq(register_id), 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] 92 |             ; shl Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]    |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:100:22
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; shr Rq(register_id), 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] 100 |             ; shr Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:108:22
[INFO] [stdout]     |
[INFO] [stdout] 108 |             ; rcl Rq(register_id), 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] 108 |             ; rcl Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:116:22
[INFO] [stdout]     |
[INFO] [stdout] 116 |             ; rcr Rq(register_id), 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] 116 |             ; rcr Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:124:22
[INFO] [stdout]     |
[INFO] [stdout] 124 |             ; sal Rq(register_id), 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] 124 |             ; sal Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:132:22
[INFO] [stdout]     |
[INFO] [stdout] 132 |             ; sar Rq(register_id), 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] 132 |             ; sar Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:140:22
[INFO] [stdout]     |
[INFO] [stdout] 140 |             ; xor Rq(register_id), 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] 140 |             ; xor Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:148:22
[INFO] [stdout]     |
[INFO] [stdout] 148 |             ; sub Rq(register_id), 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] 148 |             ; sub Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:156:22
[INFO] [stdout]     |
[INFO] [stdout] 156 |             ; add Rq(register_id), 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] 156 |             ; add Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:164:39
[INFO] [stdout]     |
[INFO] [stdout] 164 |             ; and Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |             ; and Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:164:22
[INFO] [stdout]     |
[INFO] [stdout] 164 |             ; and Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |             ; and Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:172:38
[INFO] [stdout]     |
[INFO] [stdout] 172 |             ; or Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; or Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:172:21
[INFO] [stdout]     |
[INFO] [stdout] 172 |             ; or Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; or Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                     ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:180:38
[INFO] [stdout]     |
[INFO] [stdout] 180 |             ; bt Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 |             ; bt Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:180:21
[INFO] [stdout]     |
[INFO] [stdout] 180 |             ; bt Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 |             ; bt Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                     ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:188:22
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; cmp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmp Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:188:39
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; cmp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmp Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:196:39
[INFO] [stdout]     |
[INFO] [stdout] 196 |             ; mov Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 196 |             ; mov Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:196:22
[INFO] [stdout]     |
[INFO] [stdout] 196 |             ; mov Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 196 |             ; mov Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:204:23
[INFO] [stdout]     |
[INFO] [stdout] 204 |             ; xchg Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; xchg Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:204:40
[INFO] [stdout]     |
[INFO] [stdout] 204 |             ; xchg Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; xchg Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:212:40
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; test Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; test Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:212:23
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; test Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; test Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:220:24
[INFO] [stdout]     |
[INFO] [stdout] 220 |             ; cmova Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 220 |             ; cmova Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:220:41
[INFO] [stdout]     |
[INFO] [stdout] 220 |             ; cmova Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 220 |             ; cmova Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:228:24
[INFO] [stdout]     |
[INFO] [stdout] 228 |             ; cmovb Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 228 |             ; cmovb Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:228:41
[INFO] [stdout]     |
[INFO] [stdout] 228 |             ; cmovb Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 228 |             ; cmovb Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:236:24
[INFO] [stdout]     |
[INFO] [stdout] 236 |             ; cmovc Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovc Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:236:41
[INFO] [stdout]     |
[INFO] [stdout] 236 |             ; cmovc Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovc Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:244:24
[INFO] [stdout]     |
[INFO] [stdout] 244 |             ; cmove Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 |             ; cmove Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:244:41
[INFO] [stdout]     |
[INFO] [stdout] 244 |             ; cmove Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 |             ; cmove Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:252:24
[INFO] [stdout]     |
[INFO] [stdout] 252 |             ; cmovg Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 252 |             ; cmovg Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:252:41
[INFO] [stdout]     |
[INFO] [stdout] 252 |             ; cmovg Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 252 |             ; cmovg Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:260:24
[INFO] [stdout]     |
[INFO] [stdout] 260 |             ; cmovl Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovl Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:260:41
[INFO] [stdout]     |
[INFO] [stdout] 260 |             ; cmovl Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovl Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:268:24
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ; cmovo Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ; cmovo Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:268:41
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ; cmovo Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ; cmovo Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:276:24
[INFO] [stdout]     |
[INFO] [stdout] 276 |             ; cmovp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 |             ; cmovp Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:276:41
[INFO] [stdout]     |
[INFO] [stdout] 276 |             ; cmovp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 |             ; cmovp Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:284:24
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; cmovs Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovs Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:284:41
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; cmovs Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovs Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:292:24
[INFO] [stdout]     |
[INFO] [stdout] 292 |             ; cmovz Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovz Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:292:41
[INFO] [stdout]     |
[INFO] [stdout] 292 |             ; cmovz Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovz Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:300:25
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; cmovae Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovae Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:300:42
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; cmovae Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovae Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:308:25
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ; cmovge Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovge Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:308:42
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ; cmovge Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovge Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:316:25
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; cmovle Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovle Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:316:42
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; cmovle Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovle Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:324:25
[INFO] [stdout]     |
[INFO] [stdout] 324 |             ; cmovna Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovna Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:324:42
[INFO] [stdout]     |
[INFO] [stdout] 324 |             ; cmovna Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovna Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:332:25
[INFO] [stdout]     |
[INFO] [stdout] 332 |             ; cmovnb Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnb Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:332:42
[INFO] [stdout]     |
[INFO] [stdout] 332 |             ; cmovnb Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnb Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:340:25
[INFO] [stdout]     |
[INFO] [stdout] 340 |             ; cmovnc Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 340 |             ; cmovnc Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:340:42
[INFO] [stdout]     |
[INFO] [stdout] 340 |             ; cmovnc Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 340 |             ; cmovnc Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:348:25
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; cmovne Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovne Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:348:42
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; cmovne Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovne Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:356:25
[INFO] [stdout]     |
[INFO] [stdout] 356 |             ; cmovng Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 |             ; cmovng Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:356:42
[INFO] [stdout]     |
[INFO] [stdout] 356 |             ; cmovng Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 |             ; cmovng Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:364:25
[INFO] [stdout]     |
[INFO] [stdout] 364 |             ; cmovnl Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 |             ; cmovnl Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:364:42
[INFO] [stdout]     |
[INFO] [stdout] 364 |             ; cmovnl Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 |             ; cmovnl Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:372:25
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; cmovno Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovno Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:372:42
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; cmovno Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovno Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:380:25
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; cmovnp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnp Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:380:42
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; cmovnp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnp Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:388:25
[INFO] [stdout]     |
[INFO] [stdout] 388 |             ; cmovns Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 |             ; cmovns Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:388:42
[INFO] [stdout]     |
[INFO] [stdout] 388 |             ; cmovns Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 |             ; cmovns Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:396:25
[INFO] [stdout]     |
[INFO] [stdout] 396 |             ; cmovnz Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 |             ; cmovnz Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:396:42
[INFO] [stdout]     |
[INFO] [stdout] 396 |             ; cmovnz Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 |             ; cmovnz Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:404:25
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; cmovpe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovpe Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:404:42
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; cmovpe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovpe Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:412:25
[INFO] [stdout]     |
[INFO] [stdout] 412 |             ; cmovpo Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovpo Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:412:42
[INFO] [stdout]     |
[INFO] [stdout] 412 |             ; cmovpo Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovpo Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:420:25
[INFO] [stdout]     |
[INFO] [stdout] 420 |             ; cmovbe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovbe Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:420:42
[INFO] [stdout]     |
[INFO] [stdout] 420 |             ; cmovbe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovbe Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:428:26
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; cmovnae Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnae Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:428:43
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; cmovnae Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnae Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                           ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:436:26
[INFO] [stdout]     |
[INFO] [stdout] 436 |             ; cmovnbe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 |             ; cmovnbe Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:436:43
[INFO] [stdout]     |
[INFO] [stdout] 436 |             ; cmovnbe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 |             ; cmovnbe Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                           ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:444:26
[INFO] [stdout]     |
[INFO] [stdout] 444 |             ; cmovnle Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 444 |             ; cmovnle Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:444:43
[INFO] [stdout]     |
[INFO] [stdout] 444 |             ; cmovnle Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 444 |             ; cmovnle Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                           ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:452:26
[INFO] [stdout]     |
[INFO] [stdout] 452 |             ; cmovnge Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnge Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:452:43
[INFO] [stdout]     |
[INFO] [stdout] 452 |             ; cmovnge Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnge Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                           ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:473:22
[INFO] [stdout]     |
[INFO] [stdout] 473 |             ; not Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; not Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:479:22
[INFO] [stdout]     |
[INFO] [stdout] 479 |             ; not Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 479 |             ; not Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:487:22
[INFO] [stdout]     |
[INFO] [stdout] 487 |             ; neg Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; neg Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:493:22
[INFO] [stdout]     |
[INFO] [stdout] 493 |             ; neg Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 |             ; neg Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:501:22
[INFO] [stdout]     |
[INFO] [stdout] 501 |             ; inc Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 501 |             ; inc Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:507:22
[INFO] [stdout]     |
[INFO] [stdout] 507 |             ; dec Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 507 |             ; dec Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:515:22
[INFO] [stdout]     |
[INFO] [stdout] 515 |             ; dec Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 515 |             ; dec Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:521:22
[INFO] [stdout]     |
[INFO] [stdout] 521 |             ; inc Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 521 |             ; inc Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:530:22
[INFO] [stdout]     |
[INFO] [stdout] 530 |             ; add Rq(register_id), random_byte as i32
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; add Rq(<u8 as Into<_>>::into(register_id)), random_byte as i32
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:536:22
[INFO] [stdout]     |
[INFO] [stdout] 536 |             ; sub Rq(register_id), random_byte as i32
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 536 |             ; sub Rq(<u8 as Into<_>>::into(register_id)), random_byte as i32
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:545:22
[INFO] [stdout]     |
[INFO] [stdout] 545 |             ; sub Rq(register_id), random_byte as i32
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 545 |             ; sub Rq(<u8 as Into<_>>::into(register_id)), random_byte as i32
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:551:22
[INFO] [stdout]     |
[INFO] [stdout] 551 |             ; add Rq(register_id), random_byte as i32
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 551 |             ; add Rq(<u8 as Into<_>>::into(register_id)), random_byte as i32
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:560:22
[INFO] [stdout]     |
[INFO] [stdout] 560 |             ; ror Rq(register_id), random_byte 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] 560 |             ; ror Rq(<u8 as Into<_>>::into(register_id)), random_byte as i8
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:566:22
[INFO] [stdout]     |
[INFO] [stdout] 566 |             ; rol Rq(register_id), random_byte 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] 566 |             ; rol Rq(<u8 as Into<_>>::into(register_id)), random_byte as i8
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:575:22
[INFO] [stdout]     |
[INFO] [stdout] 575 |             ; rol Rq(register_id), random_byte 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] 575 |             ; rol Rq(<u8 as Into<_>>::into(register_id)), random_byte as i8
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:581:22
[INFO] [stdout]     |
[INFO] [stdout] 581 |             ; ror Rq(register_id), random_byte 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] 581 |             ; ror Rq(<u8 as Into<_>>::into(register_id)), random_byte as i8
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:72:22
[INFO] [stdout]    |
[INFO] [stdout] 72 |             ; pop Rd(link_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; pop Rd(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:73:23
[INFO] [stdout]    |
[INFO] [stdout] 73 |             ; push Rd(link_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; push Rd(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:74:22
[INFO] [stdout]    |
[INFO] [stdout] 74 |             ; pop Rd(payload_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 |             ; pop Rd(<u8 as Into<_>>::into(payload_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:52:22
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; pop Rq(indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 52 |             ; pop Rq(<u8 as Into<_>>::into(indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:80:23
[INFO] [stdout]    |
[INFO] [stdout] 80 |             ; push Rd(payload_indexer_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 |             ; push Rd(<u8 as Into<_>>::into(payload_indexer_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:81:22
[INFO] [stdout]    |
[INFO] [stdout] 81 |             ; pop Rd(jmp_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 |             ; pop Rd(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:83:23
[INFO] [stdout]    |
[INFO] [stdout] 83 |             ; push Rd(link_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 |             ; push Rd(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:84:22
[INFO] [stdout]    |
[INFO] [stdout] 84 |             ; pop Rd(key_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; pop Rd(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:86:32
[INFO] [stdout]    |
[INFO] [stdout] 86 |             ; mov al, BYTE [Rd(key_indexer_register_id)]
[INFO] [stdout]    |                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 86 |             ; mov al, BYTE [Rd(<u8 as Into<_>>::into(key_indexer_register_id))]
[INFO] [stdout]    |                                ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:66:45
[INFO] [stdout]    |
[INFO] [stdout] 66 | ...                   ; xor DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |                             ; xor DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:87:28
[INFO] [stdout]    |
[INFO] [stdout] 87 |             ; xor BYTE [Rd(payload_indexer_register_id)], al
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 |             ; xor BYTE [Rd(<u8 as Into<_>>::into(payload_indexer_register_id))], al
[INFO] [stdout]    |                            ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:88:22
[INFO] [stdout]    |
[INFO] [stdout] 88 |             ; inc Rd(payload_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |             ; inc Rd(<u8 as Into<_>>::into(payload_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:89:22
[INFO] [stdout]    |
[INFO] [stdout] 89 |             ; inc Rd(key_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; inc Rd(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:71:45
[INFO] [stdout]    |
[INFO] [stdout] 71 | ...                   ; sub DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 |                             ; sub DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:90:28
[INFO] [stdout]    |
[INFO] [stdout] 90 |             ; cmp WORD [Rd(payload_indexer_register_id)], 0x4242
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmp WORD [Rd(<u8 as Into<_>>::into(payload_indexer_register_id))], 0x4242
[INFO] [stdout]    |                            ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:92:28
[INFO] [stdout]    |
[INFO] [stdout] 92 |             ; cmp BYTE [Rd(key_indexer_register_id)], 'A' 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] 92 |             ; cmp BYTE [Rd(<u8 as Into<_>>::into(key_indexer_register_id))], 'A' as i8
[INFO] [stdout]    |                            ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:96:22
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; jmp Rd(jmp_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; jmp Rd(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:76:45
[INFO] [stdout]    |
[INFO] [stdout] 76 | ...                   ; add DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 |                             ; add DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:82:22
[INFO] [stdout]    |
[INFO] [stdout] 82 |             ; pop Rq(link_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; pop Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:83:23
[INFO] [stdout]    |
[INFO] [stdout] 83 |             ; push Rq(link_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 |             ; push Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:91:22
[INFO] [stdout]    |
[INFO] [stdout] 91 |             ; pop Rq(jmp_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 |             ; pop Rq(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:81:45
[INFO] [stdout]    |
[INFO] [stdout] 81 | ...                   ; rol DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) 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] 81 |                             ; rol DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i8
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:86:45
[INFO] [stdout]    |
[INFO] [stdout] 86 | ...                   ; ror DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) 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] 86 |                             ; ror DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i8
[INFO] [stdout]    |                                             ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/schema/x64.rs:93:41
[INFO] [stdout]    |
[INFO] [stdout] 93 |                         ; not DWORD [Rq(indexer_register_id) + index]
[INFO] [stdout]    |                                         ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |                         ; not DWORD [Rq(<u8 as Into<_>>::into(indexer_register_id)) + index]
[INFO] [stdout]    |                                         ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/schema/x64.rs:106:22
[INFO] [stdout]     |
[INFO] [stdout] 106 |             ; jmp Rq(indexer_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 |             ; jmp Rq(<u8 as Into<_>>::into(indexer_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:50:22
[INFO] [stdout]    |
[INFO] [stdout] 50 |             ; pop Rd(indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 |             ; pop Rd(<u8 as Into<_>>::into(indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:52:22
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; mov Rb(seed_register_id), seed 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] 52 |             ; mov Rb(<u8 as Into<_>>::into(seed_register_id)), seed as i8
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:54:65
[INFO] [stdout]    |
[INFO] [stdout] 54 |             ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(seed_register_id)
[INFO] [stdout]    |                                                                 ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |             ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(<u8 as Into<_>>::into(seed_register_id))
[INFO] [stdout]    |                                                                 ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:93:23
[INFO] [stdout]    |
[INFO] [stdout] 93 |             ; push Rq(link_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |             ; push Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:54:28
[INFO] [stdout]    |
[INFO] [stdout] 54 |             ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(seed_register_id)
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |             ; xor BYTE [Rd(<u8 as Into<_>>::into(indexer_register_id)) + ecx + 19], Rb(seed_register_id)
[INFO] [stdout]    |                            ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:94:22
[INFO] [stdout]    |
[INFO] [stdout] 94 |             ; pop Rq(key_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 |             ; pop Rq(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:99:22
[INFO] [stdout]    |
[INFO] [stdout] 99 |             ; inc Rq(key_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 |             ; inc Rq(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:55:22
[INFO] [stdout]    |
[INFO] [stdout] 55 |             ; add Rb(seed_register_id), BYTE [Rd(indexer_register_id) + ecx + 19]
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 |             ; add Rb(<u8 as Into<_>>::into(seed_register_id)), BYTE [Rd(indexer_register_id) + ecx + 19]
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:106:22
[INFO] [stdout]     |
[INFO] [stdout] 106 |             ; jmp Rq(jmp_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 |             ; jmp Rq(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:130:22
[INFO] [stdout]     |
[INFO] [stdout] 130 |             ; pop Rq(link_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 |             ; pop Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:131:23
[INFO] [stdout]     |
[INFO] [stdout] 131 |             ; push Rq(link_register_id)
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 |             ; push Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]     |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:139:22
[INFO] [stdout]     |
[INFO] [stdout] 139 |             ; pop Rq(jmp_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 139 |             ; pop Rq(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:141:23
[INFO] [stdout]     |
[INFO] [stdout] 141 |             ; push Rq(link_register_id)
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 |             ; push Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]     |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x32.rs:55:50
[INFO] [stdout]    |
[INFO] [stdout] 55 |             ; add Rb(seed_register_id), BYTE [Rd(indexer_register_id) + ecx + 19]
[INFO] [stdout]    |                                                  ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 |             ; add Rb(seed_register_id), BYTE [Rd(<u8 as Into<_>>::into(indexer_register_id)) + ecx + 19]
[INFO] [stdout]    |                                                  ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:142:22
[INFO] [stdout]     |
[INFO] [stdout] 142 |             ; pop Rq(key_indexer_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |             ; pop Rq(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:47:22
[INFO] [stdout]    |
[INFO] [stdout] 47 |             ; mov Rb(seed_register_id), seed 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] 47 |             ; mov Rb(<u8 as Into<_>>::into(seed_register_id)), seed as i8
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:49:22
[INFO] [stdout]    |
[INFO] [stdout] 49 |             ; lea Rq(indexer_register_id), [>data - 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] 49 |             ; lea Rq(<u8 as Into<_>>::into(indexer_register_id)), [>data - 1]
[INFO] [stdout]    |                      ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:51:60
[INFO] [stdout]    |
[INFO] [stdout] 51 |             ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(seed_register_id)
[INFO] [stdout]    |                                                            ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 |             ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(<u8 as Into<_>>::into(seed_register_id))
[INFO] [stdout]    |                                                            ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:51:28
[INFO] [stdout]    |
[INFO] [stdout] 51 |             ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(seed_register_id)
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 |             ; xor BYTE [Rq(<u8 as Into<_>>::into(indexer_register_id)) + rcx], Rb(seed_register_id)
[INFO] [stdout]    |                            ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:52:22
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; add Rb(seed_register_id), BYTE [Rq(indexer_register_id) + rcx]
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; add Rb(<u8 as Into<_>>::into(seed_register_id)), BYTE [Rq(indexer_register_id) + rcx]
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/sgn/x64.rs:52:50
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; add Rb(seed_register_id), BYTE [Rq(indexer_register_id) + rcx]
[INFO] [stdout]    |                                                  ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 |             ; add Rb(seed_register_id), BYTE [Rq(<u8 as Into<_>>::into(indexer_register_id)) + rcx]
[INFO] [stdout]    |                                                  ++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x64_arch/garbage.rs:76:22
[INFO] [stdout]    |
[INFO] [stdout] 76 |             ; rol Rq(register_id), 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] 76 |             ; rol Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]    |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x64_arch/garbage.rs:84:22
[INFO] [stdout]    |
[INFO] [stdout] 84 |             ; ror Rq(register_id), 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] 84 |             ; ror Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]    |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/x64_arch/garbage.rs:92:22
[INFO] [stdout]    |
[INFO] [stdout] 92 |             ; shl Rq(register_id), 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] 92 |             ; shl Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]    |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:100:22
[INFO] [stdout]     |
[INFO] [stdout] 100 |             ; shr Rq(register_id), 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] 100 |             ; shr Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:108:22
[INFO] [stdout]     |
[INFO] [stdout] 108 |             ; rcl Rq(register_id), 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] 108 |             ; rcl Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:116:22
[INFO] [stdout]     |
[INFO] [stdout] 116 |             ; rcr Rq(register_id), 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] 116 |             ; rcr Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:124:22
[INFO] [stdout]     |
[INFO] [stdout] 124 |             ; sal Rq(register_id), 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] 124 |             ; sal Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:147:22
[INFO] [stdout]     |
[INFO] [stdout] 147 |             ; inc Rq(key_indexer_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 147 |             ; inc Rq(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:154:22
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; jmp Rq(jmp_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; jmp Rq(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:132:22
[INFO] [stdout]     |
[INFO] [stdout] 132 |             ; sar Rq(register_id), 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] 132 |             ; sar Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:140:22
[INFO] [stdout]     |
[INFO] [stdout] 140 |             ; xor Rq(register_id), 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] 140 |             ; xor Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:148:22
[INFO] [stdout]     |
[INFO] [stdout] 148 |             ; sub Rq(register_id), 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] 148 |             ; sub Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:156:22
[INFO] [stdout]     |
[INFO] [stdout] 156 |             ; add Rq(register_id), 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] 156 |             ; add Rq(<u8 as Into<_>>::into(register_id)), 0
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:164:39
[INFO] [stdout]     |
[INFO] [stdout] 164 |             ; and Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |             ; and Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:164:22
[INFO] [stdout]     |
[INFO] [stdout] 164 |             ; and Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |             ; and Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:172:38
[INFO] [stdout]     |
[INFO] [stdout] 172 |             ; or Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; or Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:172:21
[INFO] [stdout]     |
[INFO] [stdout] 172 |             ; or Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; or Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                     ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:180:38
[INFO] [stdout]     |
[INFO] [stdout] 180 |             ; bt Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 |             ; bt Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:180:21
[INFO] [stdout]     |
[INFO] [stdout] 180 |             ; bt Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 |             ; bt Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                     ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:188:22
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; cmp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmp Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:188:39
[INFO] [stdout]     |
[INFO] [stdout] 188 |             ; cmp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmp Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:196:39
[INFO] [stdout]     |
[INFO] [stdout] 196 |             ; mov Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 196 |             ; mov Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:196:22
[INFO] [stdout]     |
[INFO] [stdout] 196 |             ; mov Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 196 |             ; mov Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:204:23
[INFO] [stdout]     |
[INFO] [stdout] 204 |             ; xchg Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; xchg Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:204:40
[INFO] [stdout]     |
[INFO] [stdout] 204 |             ; xchg Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; xchg Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:212:40
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; test Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; test Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:212:23
[INFO] [stdout]     |
[INFO] [stdout] 212 |             ; test Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; test Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                       ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:220:24
[INFO] [stdout]     |
[INFO] [stdout] 220 |             ; cmova Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 220 |             ; cmova Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:220:41
[INFO] [stdout]     |
[INFO] [stdout] 220 |             ; cmova Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 220 |             ; cmova Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:228:24
[INFO] [stdout]     |
[INFO] [stdout] 228 |             ; cmovb Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 228 |             ; cmovb Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:228:41
[INFO] [stdout]     |
[INFO] [stdout] 228 |             ; cmovb Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 228 |             ; cmovb Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:236:24
[INFO] [stdout]     |
[INFO] [stdout] 236 |             ; cmovc Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovc Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:236:41
[INFO] [stdout]     |
[INFO] [stdout] 236 |             ; cmovc Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovc Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:244:24
[INFO] [stdout]     |
[INFO] [stdout] 244 |             ; cmove Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 |             ; cmove Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:244:41
[INFO] [stdout]     |
[INFO] [stdout] 244 |             ; cmove Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 |             ; cmove Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:252:24
[INFO] [stdout]     |
[INFO] [stdout] 252 |             ; cmovg Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 252 |             ; cmovg Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:252:41
[INFO] [stdout]     |
[INFO] [stdout] 252 |             ; cmovg Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 252 |             ; cmovg Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:260:24
[INFO] [stdout]     |
[INFO] [stdout] 260 |             ; cmovl Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovl Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:260:41
[INFO] [stdout]     |
[INFO] [stdout] 260 |             ; cmovl Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovl Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:268:24
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ; cmovo Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ; cmovo Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:268:41
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ; cmovo Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 |             ; cmovo Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:276:24
[INFO] [stdout]     |
[INFO] [stdout] 276 |             ; cmovp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 |             ; cmovp Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:276:41
[INFO] [stdout]     |
[INFO] [stdout] 276 |             ; cmovp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 |             ; cmovp Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:284:24
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; cmovs Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovs Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:284:41
[INFO] [stdout]     |
[INFO] [stdout] 284 |             ; cmovs Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovs Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:292:24
[INFO] [stdout]     |
[INFO] [stdout] 292 |             ; cmovz Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovz Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                        ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:292:41
[INFO] [stdout]     |
[INFO] [stdout] 292 |             ; cmovz Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovz Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:300:25
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; cmovae Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovae Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:300:42
[INFO] [stdout]     |
[INFO] [stdout] 300 |             ; cmovae Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovae Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:308:25
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ; cmovge Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovge Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:308:42
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ; cmovge Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovge Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:316:25
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; cmovle Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovle Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:316:42
[INFO] [stdout]     |
[INFO] [stdout] 316 |             ; cmovle Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovle Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:324:25
[INFO] [stdout]     |
[INFO] [stdout] 324 |             ; cmovna Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovna Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:324:42
[INFO] [stdout]     |
[INFO] [stdout] 324 |             ; cmovna Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovna Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:332:25
[INFO] [stdout]     |
[INFO] [stdout] 332 |             ; cmovnb Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnb Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:332:42
[INFO] [stdout]     |
[INFO] [stdout] 332 |             ; cmovnb Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnb Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:340:25
[INFO] [stdout]     |
[INFO] [stdout] 340 |             ; cmovnc Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 340 |             ; cmovnc Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:340:42
[INFO] [stdout]     |
[INFO] [stdout] 340 |             ; cmovnc Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 340 |             ; cmovnc Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:348:25
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; cmovne Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovne Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:348:42
[INFO] [stdout]     |
[INFO] [stdout] 348 |             ; cmovne Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovne Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:356:25
[INFO] [stdout]     |
[INFO] [stdout] 356 |             ; cmovng Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 |             ; cmovng Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:356:42
[INFO] [stdout]     |
[INFO] [stdout] 356 |             ; cmovng Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 |             ; cmovng Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:364:25
[INFO] [stdout]     |
[INFO] [stdout] 364 |             ; cmovnl Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 |             ; cmovnl Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:364:42
[INFO] [stdout]     |
[INFO] [stdout] 364 |             ; cmovnl Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 |             ; cmovnl Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:372:25
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; cmovno Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovno Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:372:42
[INFO] [stdout]     |
[INFO] [stdout] 372 |             ; cmovno Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovno Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:380:25
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; cmovnp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnp Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:380:42
[INFO] [stdout]     |
[INFO] [stdout] 380 |             ; cmovnp Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnp Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:388:25
[INFO] [stdout]     |
[INFO] [stdout] 388 |             ; cmovns Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 |             ; cmovns Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:388:42
[INFO] [stdout]     |
[INFO] [stdout] 388 |             ; cmovns Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 |             ; cmovns Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:396:25
[INFO] [stdout]     |
[INFO] [stdout] 396 |             ; cmovnz Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 |             ; cmovnz Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:396:42
[INFO] [stdout]     |
[INFO] [stdout] 396 |             ; cmovnz Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 |             ; cmovnz Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:404:25
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; cmovpe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovpe Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:404:42
[INFO] [stdout]     |
[INFO] [stdout] 404 |             ; cmovpe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovpe Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:412:25
[INFO] [stdout]     |
[INFO] [stdout] 412 |             ; cmovpo Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovpo Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:412:42
[INFO] [stdout]     |
[INFO] [stdout] 412 |             ; cmovpo Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovpo Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:420:25
[INFO] [stdout]     |
[INFO] [stdout] 420 |             ; cmovbe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovbe Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                         ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:420:42
[INFO] [stdout]     |
[INFO] [stdout] 420 |             ; cmovbe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovbe Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:428:26
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; cmovnae Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnae Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:428:43
[INFO] [stdout]     |
[INFO] [stdout] 428 |             ; cmovnae Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnae Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                           ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:436:26
[INFO] [stdout]     |
[INFO] [stdout] 436 |             ; cmovnbe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 |             ; cmovnbe Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:436:43
[INFO] [stdout]     |
[INFO] [stdout] 436 |             ; cmovnbe Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 |             ; cmovnbe Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                           ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:444:26
[INFO] [stdout]     |
[INFO] [stdout] 444 |             ; cmovnle Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 444 |             ; cmovnle Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:444:43
[INFO] [stdout]     |
[INFO] [stdout] 444 |             ; cmovnle Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 444 |             ; cmovnle Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                           ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:452:26
[INFO] [stdout]     |
[INFO] [stdout] 452 |             ; cmovnge Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnge Rq(<u8 as Into<_>>::into(register_id)), Rq(register_id)
[INFO] [stdout]     |                          ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:452:43
[INFO] [stdout]     |
[INFO] [stdout] 452 |             ; cmovnge Rq(register_id), Rq(register_id)
[INFO] [stdout]     |                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmovnge Rq(register_id), Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                                           ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:473:22
[INFO] [stdout]     |
[INFO] [stdout] 473 |             ; not Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; not Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:479:22
[INFO] [stdout]     |
[INFO] [stdout] 479 |             ; not Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 479 |             ; not Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:487:22
[INFO] [stdout]     |
[INFO] [stdout] 487 |             ; neg Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; neg Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:493:22
[INFO] [stdout]     |
[INFO] [stdout] 493 |             ; neg Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 |             ; neg Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:501:22
[INFO] [stdout]     |
[INFO] [stdout] 501 |             ; inc Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 501 |             ; inc Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ranis` (lib test) due to 149 previous errors
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:507:22
[INFO] [stdout]     |
[INFO] [stdout] 507 |             ; dec Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 507 |             ; dec Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:515:22
[INFO] [stdout]     |
[INFO] [stdout] 515 |             ; dec Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 515 |             ; dec Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:521:22
[INFO] [stdout]     |
[INFO] [stdout] 521 |             ; inc Rq(register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 521 |             ; inc Rq(<u8 as Into<_>>::into(register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:530:22
[INFO] [stdout]     |
[INFO] [stdout] 530 |             ; add Rq(register_id), random_byte as i32
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; add Rq(<u8 as Into<_>>::into(register_id)), random_byte as i32
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:536:22
[INFO] [stdout]     |
[INFO] [stdout] 536 |             ; sub Rq(register_id), random_byte as i32
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 536 |             ; sub Rq(<u8 as Into<_>>::into(register_id)), random_byte as i32
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:545:22
[INFO] [stdout]     |
[INFO] [stdout] 545 |             ; sub Rq(register_id), random_byte as i32
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 545 |             ; sub Rq(<u8 as Into<_>>::into(register_id)), random_byte as i32
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:551:22
[INFO] [stdout]     |
[INFO] [stdout] 551 |             ; add Rq(register_id), random_byte as i32
[INFO] [stdout]     |                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 551 |             ; add Rq(<u8 as Into<_>>::into(register_id)), random_byte as i32
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:560:22
[INFO] [stdout]     |
[INFO] [stdout] 560 |             ; ror Rq(register_id), random_byte 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] 560 |             ; ror Rq(<u8 as Into<_>>::into(register_id)), random_byte as i8
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:566:22
[INFO] [stdout]     |
[INFO] [stdout] 566 |             ; rol Rq(register_id), random_byte 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] 566 |             ; rol Rq(<u8 as Into<_>>::into(register_id)), random_byte as i8
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:575:22
[INFO] [stdout]     |
[INFO] [stdout] 575 |             ; rol Rq(register_id), random_byte 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] 575 |             ; rol Rq(<u8 as Into<_>>::into(register_id)), random_byte as i8
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/x64_arch/garbage.rs:581:22
[INFO] [stdout]     |
[INFO] [stdout] 581 |             ; ror Rq(register_id), random_byte 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] 581 |             ; ror Rq(<u8 as Into<_>>::into(register_id)), random_byte as i8
[INFO] [stdout]     |                      ++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:72:22
[INFO] [stdout]    |
[INFO] [stdout] 72 |             ; pop Rd(link_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; pop Rd(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:73:23
[INFO] [stdout]    |
[INFO] [stdout] 73 |             ; push Rd(link_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; push Rd(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:74:22
[INFO] [stdout]    |
[INFO] [stdout] 74 |             ; pop Rd(payload_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 |             ; pop Rd(<u8 as Into<_>>::into(payload_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:80:23
[INFO] [stdout]    |
[INFO] [stdout] 80 |             ; push Rd(payload_indexer_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 |             ; push Rd(<u8 as Into<_>>::into(payload_indexer_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:81:22
[INFO] [stdout]    |
[INFO] [stdout] 81 |             ; pop Rd(jmp_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 |             ; pop Rd(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:83:23
[INFO] [stdout]    |
[INFO] [stdout] 83 |             ; push Rd(link_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 |             ; push Rd(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:84:22
[INFO] [stdout]    |
[INFO] [stdout] 84 |             ; pop Rd(key_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; pop Rd(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:86:32
[INFO] [stdout]    |
[INFO] [stdout] 86 |             ; mov al, BYTE [Rd(key_indexer_register_id)]
[INFO] [stdout]    |                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 86 |             ; mov al, BYTE [Rd(<u8 as Into<_>>::into(key_indexer_register_id))]
[INFO] [stdout]    |                                ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:87:28
[INFO] [stdout]    |
[INFO] [stdout] 87 |             ; xor BYTE [Rd(payload_indexer_register_id)], al
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 |             ; xor BYTE [Rd(<u8 as Into<_>>::into(payload_indexer_register_id))], al
[INFO] [stdout]    |                            ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ranis` (lib) due to 149 previous errors
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:88:22
[INFO] [stdout]    |
[INFO] [stdout] 88 |             ; inc Rd(payload_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |             ; inc Rd(<u8 as Into<_>>::into(payload_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:89:22
[INFO] [stdout]    |
[INFO] [stdout] 89 |             ; inc Rd(key_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; inc Rd(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:90:28
[INFO] [stdout]    |
[INFO] [stdout] 90 |             ; cmp WORD [Rd(payload_indexer_register_id)], 0x4242
[INFO] [stdout]    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; cmp WORD [Rd(<u8 as Into<_>>::into(payload_indexer_register_id))], 0x4242
[INFO] [stdout]    |                            ++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:92:28
[INFO] [stdout]    |
[INFO] [stdout] 92 |             ; cmp BYTE [Rd(key_indexer_register_id)], 'A' 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] 92 |             ; cmp BYTE [Rd(<u8 as Into<_>>::into(key_indexer_register_id))], 'A' as i8
[INFO] [stdout]    |                            ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x32.rs:96:22
[INFO] [stdout]    |
[INFO] [stdout] 96 |             ; jmp Rd(jmp_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; jmp Rd(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:82:22
[INFO] [stdout]    |
[INFO] [stdout] 82 |             ; pop Rq(link_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; pop Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:83:23
[INFO] [stdout]    |
[INFO] [stdout] 83 |             ; push Rq(link_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 |             ; push Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:91:22
[INFO] [stdout]    |
[INFO] [stdout] 91 |             ; pop Rq(jmp_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 |             ; pop Rq(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:93:23
[INFO] [stdout]    |
[INFO] [stdout] 93 |             ; push Rq(link_register_id)
[INFO] [stdout]    |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |             ; push Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]    |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:94:22
[INFO] [stdout]    |
[INFO] [stdout] 94 |             ; pop Rq(key_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 |             ; pop Rq(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/xor_dynamic/x64.rs:99:22
[INFO] [stdout]    |
[INFO] [stdout] 99 |             ; inc Rq(key_indexer_register_id)
[INFO] [stdout]    |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 |             ; inc Rq(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]    |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:106:22
[INFO] [stdout]     |
[INFO] [stdout] 106 |             ; jmp Rq(jmp_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 |             ; jmp Rq(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:130:22
[INFO] [stdout]     |
[INFO] [stdout] 130 |             ; pop Rq(link_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 |             ; pop Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:131:23
[INFO] [stdout]     |
[INFO] [stdout] 131 |             ; push Rq(link_register_id)
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 |             ; push Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]     |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:139:22
[INFO] [stdout]     |
[INFO] [stdout] 139 |             ; pop Rq(jmp_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 139 |             ; pop Rq(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:141:23
[INFO] [stdout]     |
[INFO] [stdout] 141 |             ; push Rq(link_register_id)
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 |             ; push Rq(<u8 as Into<_>>::into(link_register_id))
[INFO] [stdout]     |                       ++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:142:22
[INFO] [stdout]     |
[INFO] [stdout] 142 |             ; pop Rq(key_indexer_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |             ; pop Rq(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:147:22
[INFO] [stdout]     |
[INFO] [stdout] 147 |             ; inc Rq(key_indexer_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 147 |             ; inc Rq(<u8 as Into<_>>::into(key_indexer_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/xor_dynamic/x64.rs:154:22
[INFO] [stdout]     |
[INFO] [stdout] 154 |             ; jmp Rq(jmp_register_id)
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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 |             ; jmp Rq(<u8 as Into<_>>::into(jmp_register_id))
[INFO] [stdout]     |                      ++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30", kill_on_drop: false }`
[INFO] [stdout] 3e7cd5c64e6246c03f37c9896aba58db4ed76cbc7713bb3c7fd3ab8e16988d30
