[INFO] cloning repository https://github.com/Stausee1337/emulator
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/Stausee1337/emulator" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FStausee1337%2Femulator", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FStausee1337%2Femulator'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] de75d84557af11d4fbaf61101572b7c22791bf96
[INFO] checking Stausee1337/emulator against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FStausee1337%2Femulator" "/workspace/builds/worker-0-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-0-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/Stausee1337/emulator
[INFO] finished tweaking git repo https://github.com/Stausee1337/emulator
[INFO] tweaked toml for git repo https://github.com/Stausee1337/emulator written to /workspace/builds/worker-0-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/Stausee1337/emulator 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 git repo https://github.com/Stausee1337/emulator already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-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] 2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668
[INFO] running `Command { std: "docker" "start" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", 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" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", 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" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling syn v2.0.117
[INFO] [stderr]     Checking bytemuck v1.25.0
[INFO] [stderr]    Compiling emulator_macros v0.1.0 (/opt/rustwide/workdir/emulator_macros)
[INFO] [stderr]     Checking emulator v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: unused import: `bitflags::bitflags`
[INFO] [stdout]  --> src/disasm/instruction.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use bitflags::bitflags;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `thread::sleep` and `time::Duration`
[INFO] [stdout]  --> src/cpu.rs:1:65
[INFO] [stdout]   |
[INFO] [stdout] 1 | use std::{fmt::Write, io::{Read, Seek}, ops::{Deref, DerefMut}, thread::sleep, time::Duration};
[INFO] [stdout]   |                                                                 ^^^^^^^^^^^^^  ^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: the feature `never_type` has been stable since 1.100.0 and no longer requires an attribute to enable
[INFO] [stdout]  --> src/main.rs:1:12
[INFO] [stdout]   |
[INFO] [stdout] 1 | #![feature(never_type)]
[INFO] [stdout]   |            ^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(stable_features)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `bitflags::bitflags`
[INFO] [stdout]  --> src/disasm/instruction.rs:3:5
[INFO] [stdout]   |
[INFO] [stdout] 3 | use bitflags::bitflags;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `thread::sleep` and `time::Duration`
[INFO] [stdout]  --> src/cpu.rs:1:65
[INFO] [stdout]   |
[INFO] [stdout] 1 | use std::{fmt::Write, io::{Read, Seek}, ops::{Deref, DerefMut}, thread::sleep, time::Duration};
[INFO] [stdout]   |                                                                 ^^^^^^^^^^^^^  ^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: the feature `never_type` has been stable since 1.100.0 and no longer requires an attribute to enable
[INFO] [stdout]  --> src/main.rs:1:12
[INFO] [stdout]   |
[INFO] [stdout] 1 | #![feature(never_type)]
[INFO] [stdout]   |            ^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(stable_features)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: struct `IndependentSize` is never constructed
[INFO] [stdout]    --> src/disasm/instruction.rs:214:12
[INFO] [stdout]     |
[INFO] [stdout] 214 | pub struct IndependentSize;
[INFO] [stdout]     |            ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:262:44
[INFO] [stdout]     |
[INFO] [stdout] 262 |                 instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -                 instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 262 +                 instructions8::Add { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -                 instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 262 +                 instructions8::Add { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:264:45
[INFO] [stdout]     |
[INFO] [stdout] 264 |                 instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 264 -                 instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 264 +                 instructions16::Add { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 -                 instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 264 +                 instructions16::Add { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:266:44
[INFO] [stdout]     |
[INFO] [stdout] 266 |                 instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 266 -                 instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 266 +                 instructions8::Add { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 266 -                 instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 266 +                 instructions8::Add { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:268:45
[INFO] [stdout]     |
[INFO] [stdout] 268 |                 instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 268 -                 instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 268 +                 instructions16::Add { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 -                 instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 268 +                 instructions16::Add { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:278:43
[INFO] [stdout]     |
[INFO] [stdout] 278 |                 instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 278 -                 instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 278 +                 instructions8::Or { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 -                 instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 278 +                 instructions8::Or { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:280:44
[INFO] [stdout]     |
[INFO] [stdout] 280 |                 instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 280 -                 instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 280 +                 instructions16::Or { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 280 -                 instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 280 +                 instructions16::Or { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:282:43
[INFO] [stdout]     |
[INFO] [stdout] 282 |                 instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 282 -                 instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 282 +                 instructions8::Or { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 -                 instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 282 +                 instructions8::Or { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:284:44
[INFO] [stdout]     |
[INFO] [stdout] 284 |                 instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 284 -                 instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 284 +                 instructions16::Or { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 -                 instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 284 +                 instructions16::Or { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:292:44
[INFO] [stdout]     |
[INFO] [stdout] 292 |                 instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -                 instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 292 +                 instructions8::Adc { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -                 instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 292 +                 instructions8::Adc { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:294:45
[INFO] [stdout]     |
[INFO] [stdout] 294 |                 instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 294 -                 instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 294 +                 instructions16::Adc { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 -                 instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 294 +                 instructions16::Adc { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:296:44
[INFO] [stdout]     |
[INFO] [stdout] 296 |                 instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 296 -                 instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 296 +                 instructions8::Adc { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 296 -                 instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 296 +                 instructions8::Adc { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:298:45
[INFO] [stdout]     |
[INFO] [stdout] 298 |                 instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 298 -                 instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 298 +                 instructions16::Adc { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 298 -                 instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 298 +                 instructions16::Adc { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:308:44
[INFO] [stdout]     |
[INFO] [stdout] 308 |                 instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 308 -                 instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 308 +                 instructions8::Sbb { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 308 -                 instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 308 +                 instructions8::Sbb { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:310:45
[INFO] [stdout]     |
[INFO] [stdout] 310 |                 instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 310 -                 instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 310 +                 instructions16::Sbb { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 310 -                 instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 310 +                 instructions16::Sbb { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:312:44
[INFO] [stdout]     |
[INFO] [stdout] 312 |                 instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 312 -                 instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 312 +                 instructions8::Sbb { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 312 -                 instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 312 +                 instructions8::Sbb { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:314:45
[INFO] [stdout]     |
[INFO] [stdout] 314 |                 instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 314 -                 instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 314 +                 instructions16::Sbb { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 314 -                 instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 314 +                 instructions16::Sbb { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:324:44
[INFO] [stdout]     |
[INFO] [stdout] 324 |                 instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 324 -                 instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 324 +                 instructions8::And { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 324 -                 instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 324 +                 instructions8::And { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:326:45
[INFO] [stdout]     |
[INFO] [stdout] 326 |                 instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 326 -                 instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 326 +                 instructions16::And { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 326 -                 instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 326 +                 instructions16::And { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:328:44
[INFO] [stdout]     |
[INFO] [stdout] 328 |                 instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 328 -                 instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 328 +                 instructions8::And { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 -                 instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 328 +                 instructions8::And { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:330:45
[INFO] [stdout]     |
[INFO] [stdout] 330 |                 instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 330 -                 instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 330 +                 instructions16::And { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 -                 instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 330 +                 instructions16::And { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:337:44
[INFO] [stdout]     |
[INFO] [stdout] 337 |                 instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 337 -                 instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 337 +                 instructions8::Sub { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 -                 instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 337 +                 instructions8::Sub { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:339:45
[INFO] [stdout]     |
[INFO] [stdout] 339 |                 instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 339 -                 instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 339 +                 instructions16::Sub { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 339 -                 instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 339 +                 instructions16::Sub { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:341:44
[INFO] [stdout]     |
[INFO] [stdout] 341 |                 instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 341 -                 instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 341 +                 instructions8::Sub { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 341 -                 instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 341 +                 instructions8::Sub { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:343:45
[INFO] [stdout]     |
[INFO] [stdout] 343 |                 instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -                 instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 343 +                 instructions16::Sub { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -                 instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 343 +                 instructions16::Sub { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:350:44
[INFO] [stdout]     |
[INFO] [stdout] 350 |                 instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 350 -                 instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 350 +                 instructions8::Xor { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 350 -                 instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 350 +                 instructions8::Xor { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:352:45
[INFO] [stdout]     |
[INFO] [stdout] 352 |                 instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 352 -                 instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 352 +                 instructions16::Xor { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 352 -                 instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 352 +                 instructions16::Xor { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:354:44
[INFO] [stdout]     |
[INFO] [stdout] 354 |                 instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 354 -                 instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 354 +                 instructions8::Xor { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 -                 instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 354 +                 instructions8::Xor { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:356:45
[INFO] [stdout]     |
[INFO] [stdout] 356 |                 instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 356 -                 instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 356 +                 instructions16::Xor { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 -                 instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 356 +                 instructions16::Xor { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:378:44
[INFO] [stdout]     |
[INFO] [stdout] 378 |                 instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 378 -                 instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(),
[INFO] [stdout] 378 +                 instructions::Arpl { dest: modrm.effective(), src: modrm.register().into() } .into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 378 -                 instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(),
[INFO] [stdout] 378 +                 instructions::Arpl { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() } .into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:382:24
[INFO] [stdout]     |
[INFO] [stdout] 382 |                 dest1: modrm.register().into(),
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 382 -                 dest1: modrm.register().into(),
[INFO] [stdout] 382 +                 dest1: modrm.register(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 -                 dest1: modrm.register().into(),
[INFO] [stdout] 382 +                 dest1: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:388:24
[INFO] [stdout]     |
[INFO] [stdout] 388 |                 dest1: modrm.register().into(),
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 388 -                 dest1: modrm.register().into(),
[INFO] [stdout] 388 +                 dest1: modrm.register(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 -                 dest1: modrm.register().into(),
[INFO] [stdout] 388 +                 dest1: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:397:45
[INFO] [stdout]     |
[INFO] [stdout] 397 |                 instructions8::Jo { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 397 -                 instructions8::Jo { offset: offset.into() }.into(),
[INFO] [stdout] 397 +                 instructions8::Jo { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 397 -                 instructions8::Jo { offset: offset.into() }.into(),
[INFO] [stdout] 397 +                 instructions8::Jo { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:399:46
[INFO] [stdout]     |
[INFO] [stdout] 399 |                 instructions8::Jno { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 399 -                 instructions8::Jno { offset: offset.into() }.into(),
[INFO] [stdout] 399 +                 instructions8::Jno { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 399 -                 instructions8::Jno { offset: offset.into() }.into(),
[INFO] [stdout] 399 +                 instructions8::Jno { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:401:45
[INFO] [stdout]     |
[INFO] [stdout] 401 |                 instructions8::Jb { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 401 -                 instructions8::Jb { offset: offset.into() }.into(),
[INFO] [stdout] 401 +                 instructions8::Jb { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 -                 instructions8::Jb { offset: offset.into() }.into(),
[INFO] [stdout] 401 +                 instructions8::Jb { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:403:46
[INFO] [stdout]     |
[INFO] [stdout] 403 |                 instructions8::Jae { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 403 -                 instructions8::Jae { offset: offset.into() }.into(),
[INFO] [stdout] 403 +                 instructions8::Jae { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 403 -                 instructions8::Jae { offset: offset.into() }.into(),
[INFO] [stdout] 403 +                 instructions8::Jae { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:405:45
[INFO] [stdout]     |
[INFO] [stdout] 405 |                 instructions8::Je { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 405 -                 instructions8::Je { offset: offset.into() }.into(),
[INFO] [stdout] 405 +                 instructions8::Je { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 405 -                 instructions8::Je { offset: offset.into() }.into(),
[INFO] [stdout] 405 +                 instructions8::Je { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:407:46
[INFO] [stdout]     |
[INFO] [stdout] 407 |                 instructions8::Jne { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 407 -                 instructions8::Jne { offset: offset.into() }.into(),
[INFO] [stdout] 407 +                 instructions8::Jne { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 407 -                 instructions8::Jne { offset: offset.into() }.into(),
[INFO] [stdout] 407 +                 instructions8::Jne { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:409:46
[INFO] [stdout]     |
[INFO] [stdout] 409 |                 instructions8::Jbe { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 409 -                 instructions8::Jbe { offset: offset.into() }.into(),
[INFO] [stdout] 409 +                 instructions8::Jbe { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 409 -                 instructions8::Jbe { offset: offset.into() }.into(),
[INFO] [stdout] 409 +                 instructions8::Jbe { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:411:45
[INFO] [stdout]     |
[INFO] [stdout] 411 |                 instructions8::Ja { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 instructions8::Ja { offset: offset.into() }.into(),
[INFO] [stdout] 411 +                 instructions8::Ja { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 instructions8::Ja { offset: offset.into() }.into(),
[INFO] [stdout] 411 +                 instructions8::Ja { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:413:45
[INFO] [stdout]     |
[INFO] [stdout] 413 |                 instructions8::Js { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 413 -                 instructions8::Js { offset: offset.into() }.into(),
[INFO] [stdout] 413 +                 instructions8::Js { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 413 -                 instructions8::Js { offset: offset.into() }.into(),
[INFO] [stdout] 413 +                 instructions8::Js { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:415:46
[INFO] [stdout]     |
[INFO] [stdout] 415 |                 instructions8::Jns { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 415 -                 instructions8::Jns { offset: offset.into() }.into(),
[INFO] [stdout] 415 +                 instructions8::Jns { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 -                 instructions8::Jns { offset: offset.into() }.into(),
[INFO] [stdout] 415 +                 instructions8::Jns { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:417:45
[INFO] [stdout]     |
[INFO] [stdout] 417 |                 instructions8::Jp { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 417 -                 instructions8::Jp { offset: offset.into() }.into(),
[INFO] [stdout] 417 +                 instructions8::Jp { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 417 -                 instructions8::Jp { offset: offset.into() }.into(),
[INFO] [stdout] 417 +                 instructions8::Jp { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:419:46
[INFO] [stdout]     |
[INFO] [stdout] 419 |                 instructions8::Jnp { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 419 -                 instructions8::Jnp { offset: offset.into() }.into(),
[INFO] [stdout] 419 +                 instructions8::Jnp { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 419 -                 instructions8::Jnp { offset: offset.into() }.into(),
[INFO] [stdout] 419 +                 instructions8::Jnp { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:421:45
[INFO] [stdout]     |
[INFO] [stdout] 421 |                 instructions8::Jl { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 instructions8::Jl { offset: offset.into() }.into(),
[INFO] [stdout] 421 +                 instructions8::Jl { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 instructions8::Jl { offset: offset.into() }.into(),
[INFO] [stdout] 421 +                 instructions8::Jl { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:423:46
[INFO] [stdout]     |
[INFO] [stdout] 423 |                 instructions8::Jge { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 423 -                 instructions8::Jge { offset: offset.into() }.into(),
[INFO] [stdout] 423 +                 instructions8::Jge { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 423 -                 instructions8::Jge { offset: offset.into() }.into(),
[INFO] [stdout] 423 +                 instructions8::Jge { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:425:46
[INFO] [stdout]     |
[INFO] [stdout] 425 |                 instructions8::Jle { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 425 -                 instructions8::Jle { offset: offset.into() }.into(),
[INFO] [stdout] 425 +                 instructions8::Jle { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 425 -                 instructions8::Jle { offset: offset.into() }.into(),
[INFO] [stdout] 425 +                 instructions8::Jle { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:427:45
[INFO] [stdout]     |
[INFO] [stdout] 427 |                 instructions8::Jg { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 427 -                 instructions8::Jg { offset: offset.into() }.into(),
[INFO] [stdout] 427 +                 instructions8::Jg { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 427 -                 instructions8::Jg { offset: offset.into() }.into(),
[INFO] [stdout] 427 +                 instructions8::Jg { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:433:42
[INFO] [stdout]     |
[INFO] [stdout] 433 |                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 433 -                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 433 +                 instructions8::Xchg { a: modrm.effective(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 433 -                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 433 +                 instructions8::Xchg { a: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), b: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:433:71
[INFO] [stdout]     |
[INFO] [stdout] 433 |                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |                                                                       ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 433 -                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 433 +                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 433 -                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 433 +                 instructions8::Xchg { a: modrm.effective().into(), b: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:435:43
[INFO] [stdout]     |
[INFO] [stdout] 435 |                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 435 -                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 435 +                 instructions16::Xchg { a: modrm.effective(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 435 -                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 435 +                 instructions16::Xchg { a: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), b: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:435:72
[INFO] [stdout]     |
[INFO] [stdout] 435 |                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 435 -                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 435 +                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 435 -                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 435 +                 instructions16::Xchg { a: modrm.effective().into(), b: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:437:44
[INFO] [stdout]     |
[INFO] [stdout] 437 |                 instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 437 -                 instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 437 +                 instructions8::Mov { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 437 -                 instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 437 +                 instructions8::Mov { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:439:45
[INFO] [stdout]     |
[INFO] [stdout] 439 |                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 439 -                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 439 +                 instructions16::Mov { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 439 -                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 439 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:441:44
[INFO] [stdout]     |
[INFO] [stdout] 441 |                 instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 441 +                 instructions8::Mov { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 441 +                 instructions8::Mov { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:443:45
[INFO] [stdout]     |
[INFO] [stdout] 443 |                 instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 443 -                 instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 443 +                 instructions16::Mov { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 443 -                 instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 443 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:445:45
[INFO] [stdout]     |
[INFO] [stdout] 445 |                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 445 -                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout] 445 +                 instructions16::Mov { dest: modrm.effective(), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 -                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout] 445 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:446:64
[INFO] [stdout]     |
[INFO] [stdout] 446 |             [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(),
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 446 -             [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(),
[INFO] [stdout] 446 +             [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register(), src: modrm.memory()? }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 446 -             [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(),
[INFO] [stdout] 446 +             [0x8D, modrm @ ModRM] => instructions::Lea { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()? }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:448:45
[INFO] [stdout]     |
[INFO] [stdout] 448 |                 instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 448 -                 instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 448 +                 instructions16::Mov { dest: modrm.segment_register()?, src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 448 -                 instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 448 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.segment_register()?), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:450:45
[INFO] [stdout]     |
[INFO] [stdout] 450 |                 instructions16::Pop { dest: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 450 -                 instructions16::Pop { dest: modrm.effective().into() }.into(),
[INFO] [stdout] 450 +                 instructions16::Pop { dest: modrm.effective() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 450 -                 instructions16::Pop { dest: modrm.effective().into() }.into(),
[INFO] [stdout] 450 +                 instructions16::Pop { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/disasm/decoder.rs:484:48
[INFO] [stdout]     |
[INFO] [stdout] 484 |                 instructions::RetNear { count: count.into() }.into(),
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 484 -                 instructions::RetNear { count: count.into() }.into(),
[INFO] [stdout] 484 +                 instructions::RetNear { count: count }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 484 -                 instructions::RetNear { count: count.into() }.into(),
[INFO] [stdout] 484 +                 instructions::RetNear { count: <u16 as Into<_>>::into(count) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:487:43
[INFO] [stdout]     |
[INFO] [stdout] 487 |                 instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 487 -                 instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 487 +                 instructions::Les { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 -                 instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 487 +                 instructions::Les { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:489:43
[INFO] [stdout]     |
[INFO] [stdout] 489 |                 instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 489 -                 instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 489 +                 instructions::Lds { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 489 -                 instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 489 +                 instructions::Lds { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:491:44
[INFO] [stdout]     |
[INFO] [stdout] 491 |                 instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 491 -                 instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout] 491 +                 instructions8::Mov { dest: modrm.effective(), src: src.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 491 -                 instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout] 491 +                 instructions8::Mov { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: src.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:493:45
[INFO] [stdout]     |
[INFO] [stdout] 493 |                 instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 493 -                 instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout] 493 +                 instructions16::Mov { dest: modrm.effective(), src: src.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 -                 instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout] 493 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: src.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/disasm/decoder.rs:495:47
[INFO] [stdout]     |
[INFO] [stdout] 495 |                 instructions::RetFar { count: count.into() }.into(),
[INFO] [stdout]     |                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 495 -                 instructions::RetFar { count: count.into() }.into(),
[INFO] [stdout] 495 +                 instructions::RetFar { count: count }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 495 -                 instructions::RetFar { count: count.into() }.into(),
[INFO] [stdout] 495 +                 instructions::RetFar { count: <u16 as Into<_>>::into(count) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:509:47
[INFO] [stdout]     |
[INFO] [stdout] 509 |                 instructions::Loope { offset: offset.into() }.into(),
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 509 -                 instructions::Loope { offset: offset.into() }.into(),
[INFO] [stdout] 509 +                 instructions::Loope { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 509 -                 instructions::Loope { offset: offset.into() }.into(),
[INFO] [stdout] 509 +                 instructions::Loope { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:511:46
[INFO] [stdout]     |
[INFO] [stdout] 511 |                 instructions::Loop { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 511 -                 instructions::Loop { offset: offset.into() }.into(),
[INFO] [stdout] 511 +                 instructions::Loop { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 511 -                 instructions::Loop { offset: offset.into() }.into(),
[INFO] [stdout] 511 +                 instructions::Loop { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:513:46
[INFO] [stdout]     |
[INFO] [stdout] 513 |                 instructions::Jcxz { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 513 -                 instructions::Jcxz { offset: offset.into() }.into(),
[INFO] [stdout] 513 +                 instructions::Jcxz { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 513 -                 instructions::Jcxz { offset: offset.into() }.into(),
[INFO] [stdout] 513 +                 instructions::Jcxz { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:523:49
[INFO] [stdout]     |
[INFO] [stdout] 523 |                 instructions::CallRel { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 523 -                 instructions::CallRel { offset: offset.into() }.into(),
[INFO] [stdout] 523 +                 instructions::CallRel { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 -                 instructions::CallRel { offset: offset.into() }.into(),
[INFO] [stdout] 523 +                 instructions::CallRel { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:525:50
[INFO] [stdout]     |
[INFO] [stdout] 525 |                 instructions16::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 525 -                 instructions16::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout] 525 +                 instructions16::JmpRel { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 525 -                 instructions16::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout] 525 +                 instructions16::JmpRel { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:529:49
[INFO] [stdout]     |
[INFO] [stdout] 529 |                 instructions8::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 529 -                 instructions8::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout] 529 +                 instructions8::JmpRel { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 529 -                 instructions8::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout] 529 +                 instructions8::JmpRel { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:554:66
[INFO] [stdout]     |
[INFO] [stdout] 554 |             [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 554 -             [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(),
[INFO] [stdout] 554 +             [0x80, offset @ i16] => instructions16::Jo { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 -             [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(),
[INFO] [stdout] 554 +             [0x80, offset @ i16] => instructions16::Jo { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:555:67
[INFO] [stdout]     |
[INFO] [stdout] 555 |             [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 555 -             [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(),
[INFO] [stdout] 555 +             [0x81, offset @ i16] => instructions16::Jno { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 555 -             [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(),
[INFO] [stdout] 555 +             [0x81, offset @ i16] => instructions16::Jno { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:556:66
[INFO] [stdout]     |
[INFO] [stdout] 556 |             [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 556 -             [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(),
[INFO] [stdout] 556 +             [0x82, offset @ i16] => instructions16::Jb { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 556 -             [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(),
[INFO] [stdout] 556 +             [0x82, offset @ i16] => instructions16::Jb { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:557:67
[INFO] [stdout]     |
[INFO] [stdout] 557 |             [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 557 -             [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(),
[INFO] [stdout] 557 +             [0x83, offset @ i16] => instructions16::Jae { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 557 -             [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(),
[INFO] [stdout] 557 +             [0x83, offset @ i16] => instructions16::Jae { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:558:66
[INFO] [stdout]     |
[INFO] [stdout] 558 |             [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 558 -             [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(),
[INFO] [stdout] 558 +             [0x84, offset @ i16] => instructions16::Je { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 558 -             [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(),
[INFO] [stdout] 558 +             [0x84, offset @ i16] => instructions16::Je { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:559:67
[INFO] [stdout]     |
[INFO] [stdout] 559 |             [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 559 -             [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(),
[INFO] [stdout] 559 +             [0x85, offset @ i16] => instructions16::Jne { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 559 -             [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(),
[INFO] [stdout] 559 +             [0x85, offset @ i16] => instructions16::Jne { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:560:67
[INFO] [stdout]     |
[INFO] [stdout] 560 |             [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 560 -             [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(),
[INFO] [stdout] 560 +             [0x86, offset @ i16] => instructions16::Jbe { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 560 -             [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(),
[INFO] [stdout] 560 +             [0x86, offset @ i16] => instructions16::Jbe { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:561:66
[INFO] [stdout]     |
[INFO] [stdout] 561 |             [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 561 -             [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(),
[INFO] [stdout] 561 +             [0x87, offset @ i16] => instructions16::Ja { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 561 -             [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(),
[INFO] [stdout] 561 +             [0x87, offset @ i16] => instructions16::Ja { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:562:66
[INFO] [stdout]     |
[INFO] [stdout] 562 |             [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 562 -             [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(),
[INFO] [stdout] 562 +             [0x88, offset @ i16] => instructions16::Js { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 562 -             [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(),
[INFO] [stdout] 562 +             [0x88, offset @ i16] => instructions16::Js { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:563:67
[INFO] [stdout]     |
[INFO] [stdout] 563 |             [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 563 -             [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(),
[INFO] [stdout] 563 +             [0x89, offset @ i16] => instructions16::Jns { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 563 -             [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(),
[INFO] [stdout] 563 +             [0x89, offset @ i16] => instructions16::Jns { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:564:66
[INFO] [stdout]     |
[INFO] [stdout] 564 |             [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 564 -             [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(),
[INFO] [stdout] 564 +             [0x8A, offset @ i16] => instructions16::Jp { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 564 -             [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(),
[INFO] [stdout] 564 +             [0x8A, offset @ i16] => instructions16::Jp { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:565:67
[INFO] [stdout]     |
[INFO] [stdout] 565 |             [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 565 -             [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(),
[INFO] [stdout] 565 +             [0x8B, offset @ i16] => instructions16::Jnp { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 565 -             [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(),
[INFO] [stdout] 565 +             [0x8B, offset @ i16] => instructions16::Jnp { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:566:66
[INFO] [stdout]     |
[INFO] [stdout] 566 |             [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 566 -             [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(),
[INFO] [stdout] 566 +             [0x8C, offset @ i16] => instructions16::Jl { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 566 -             [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(),
[INFO] [stdout] 566 +             [0x8C, offset @ i16] => instructions16::Jl { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:567:67
[INFO] [stdout]     |
[INFO] [stdout] 567 |             [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 567 -             [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(),
[INFO] [stdout] 567 +             [0x8D, offset @ i16] => instructions16::Jge { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 567 -             [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(),
[INFO] [stdout] 567 +             [0x8D, offset @ i16] => instructions16::Jge { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:568:67
[INFO] [stdout]     |
[INFO] [stdout] 568 |             [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 568 -             [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(),
[INFO] [stdout] 568 +             [0x8E, offset @ i16] => instructions16::Jle { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 568 -             [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(),
[INFO] [stdout] 568 +             [0x8E, offset @ i16] => instructions16::Jle { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:569:66
[INFO] [stdout]     |
[INFO] [stdout] 569 |             [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 569 -             [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(),
[INFO] [stdout] 569 +             [0x8F, offset @ i16] => instructions16::Jg { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 569 -             [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(),
[INFO] [stdout] 569 +             [0x8F, offset @ i16] => instructions16::Jg { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:576:24
[INFO] [stdout]     |
[INFO] [stdout] 576 |                 dest1: modrm.register().into(),
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 576 -                 dest1: modrm.register().into(),
[INFO] [stdout] 576 +                 dest1: modrm.register(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 576 -                 dest1: modrm.register().into(),
[INFO] [stdout] 576 +                 dest1: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:582:43
[INFO] [stdout]     |
[INFO] [stdout] 582 |                 instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 582 -                 instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 582 +                 instructions::Lss { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 582 -                 instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 582 +                 instructions::Lss { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:584:43
[INFO] [stdout]     |
[INFO] [stdout] 584 |                 instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 584 -                 instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 584 +                 instructions::Lfs { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 584 -                 instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 584 +                 instructions::Lfs { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:586:43
[INFO] [stdout]     |
[INFO] [stdout] 586 |                 instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 586 -                 instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 586 +                 instructions::Lgs { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 586 -                 instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 586 +                 instructions::Lgs { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:757:55
[INFO] [stdout]     |
[INFO] [stdout] 757 |                 return Ok(instructions16::Inc { dest: reg.into() }.into());
[INFO] [stdout]     |                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 757 -                 return Ok(instructions16::Inc { dest: reg.into() }.into());
[INFO] [stdout] 757 +                 return Ok(instructions16::Inc { dest: reg }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 757 -                 return Ok(instructions16::Inc { dest: reg.into() }.into());
[INFO] [stdout] 757 +                 return Ok(instructions16::Inc { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg) }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:761:55
[INFO] [stdout]     |
[INFO] [stdout] 761 |                 return Ok(instructions16::Dec { dest: reg.into() }.into());
[INFO] [stdout]     |                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 761 -                 return Ok(instructions16::Dec { dest: reg.into() }.into());
[INFO] [stdout] 761 +                 return Ok(instructions16::Dec { dest: reg }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 761 -                 return Ok(instructions16::Dec { dest: reg.into() }.into());
[INFO] [stdout] 761 +                 return Ok(instructions16::Dec { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg) }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:769:55
[INFO] [stdout]     |
[INFO] [stdout] 769 |                 return Ok(instructions16::Pop { dest: reg.into() }.into());
[INFO] [stdout]     |                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 769 -                 return Ok(instructions16::Pop { dest: reg.into() }.into());
[INFO] [stdout] 769 +                 return Ok(instructions16::Pop { dest: reg }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 769 -                 return Ok(instructions16::Pop { dest: reg.into() }.into());
[INFO] [stdout] 769 +                 return Ok(instructions16::Pop { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg) }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:778:79
[INFO] [stdout]     |
[INFO] [stdout] 778 |                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into());
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 778 -                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into());
[INFO] [stdout] 778 +                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 778 -                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into());
[INFO] [stdout] 778 +                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg) }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:785:54
[INFO] [stdout]     |
[INFO] [stdout] 785 |                 return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout]     |                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 785 -                 return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout] 785 +                 return Ok(instructions8::Mov { dest: reg, src: imm.into() }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 785 -                 return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout] 785 +                 return Ok(instructions8::Mov { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(reg), src: imm.into() }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:790:55
[INFO] [stdout]     |
[INFO] [stdout] 790 |                 return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout]     |                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 790 -                 return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout] 790 +                 return Ok(instructions16::Mov { dest: reg, src: imm.into() }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 790 -                 return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout] 790 +                 return Ok(instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg), src: imm.into() }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: struct `IndependentSize` is never constructed
[INFO] [stdout]    --> src/disasm/instruction.rs:214:12
[INFO] [stdout]     |
[INFO] [stdout] 214 | pub struct IndependentSize;
[INFO] [stdout]     |            ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:262:44
[INFO] [stdout]     |
[INFO] [stdout] 262 |                 instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -                 instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 262 +                 instructions8::Add { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -                 instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 262 +                 instructions8::Add { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:264:45
[INFO] [stdout]     |
[INFO] [stdout] 264 |                 instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 264 -                 instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 264 +                 instructions16::Add { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 -                 instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 264 +                 instructions16::Add { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:266:44
[INFO] [stdout]     |
[INFO] [stdout] 266 |                 instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 266 -                 instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 266 +                 instructions8::Add { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 266 -                 instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 266 +                 instructions8::Add { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:268:45
[INFO] [stdout]     |
[INFO] [stdout] 268 |                 instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 268 -                 instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 268 +                 instructions16::Add { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 -                 instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 268 +                 instructions16::Add { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:278:43
[INFO] [stdout]     |
[INFO] [stdout] 278 |                 instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 278 -                 instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 278 +                 instructions8::Or { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 -                 instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 278 +                 instructions8::Or { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:280:44
[INFO] [stdout]     |
[INFO] [stdout] 280 |                 instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 280 -                 instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 280 +                 instructions16::Or { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 280 -                 instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 280 +                 instructions16::Or { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:282:43
[INFO] [stdout]     |
[INFO] [stdout] 282 |                 instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 282 -                 instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 282 +                 instructions8::Or { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 -                 instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 282 +                 instructions8::Or { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `emulator` (bin "emulator" test) due to 97 previous errors; 4 warnings emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:284:44
[INFO] [stdout]     |
[INFO] [stdout] 284 |                 instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 284 -                 instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 284 +                 instructions16::Or { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 -                 instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 284 +                 instructions16::Or { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:292:44
[INFO] [stdout]     |
[INFO] [stdout] 292 |                 instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -                 instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 292 +                 instructions8::Adc { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -                 instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 292 +                 instructions8::Adc { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:294:45
[INFO] [stdout]     |
[INFO] [stdout] 294 |                 instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 294 -                 instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 294 +                 instructions16::Adc { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 -                 instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 294 +                 instructions16::Adc { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:296:44
[INFO] [stdout]     |
[INFO] [stdout] 296 |                 instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 296 -                 instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 296 +                 instructions8::Adc { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 296 -                 instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 296 +                 instructions8::Adc { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:298:45
[INFO] [stdout]     |
[INFO] [stdout] 298 |                 instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 298 -                 instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 298 +                 instructions16::Adc { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 298 -                 instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 298 +                 instructions16::Adc { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:308:44
[INFO] [stdout]     |
[INFO] [stdout] 308 |                 instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 308 -                 instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 308 +                 instructions8::Sbb { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 308 -                 instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 308 +                 instructions8::Sbb { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:310:45
[INFO] [stdout]     |
[INFO] [stdout] 310 |                 instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 310 -                 instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 310 +                 instructions16::Sbb { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 310 -                 instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 310 +                 instructions16::Sbb { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:312:44
[INFO] [stdout]     |
[INFO] [stdout] 312 |                 instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 312 -                 instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 312 +                 instructions8::Sbb { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 312 -                 instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 312 +                 instructions8::Sbb { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:314:45
[INFO] [stdout]     |
[INFO] [stdout] 314 |                 instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 314 -                 instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 314 +                 instructions16::Sbb { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 314 -                 instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 314 +                 instructions16::Sbb { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:324:44
[INFO] [stdout]     |
[INFO] [stdout] 324 |                 instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 324 -                 instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 324 +                 instructions8::And { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 324 -                 instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 324 +                 instructions8::And { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:326:45
[INFO] [stdout]     |
[INFO] [stdout] 326 |                 instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 326 -                 instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 326 +                 instructions16::And { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 326 -                 instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 326 +                 instructions16::And { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:328:44
[INFO] [stdout]     |
[INFO] [stdout] 328 |                 instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 328 -                 instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 328 +                 instructions8::And { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 -                 instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 328 +                 instructions8::And { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:330:45
[INFO] [stdout]     |
[INFO] [stdout] 330 |                 instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 330 -                 instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 330 +                 instructions16::And { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 -                 instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 330 +                 instructions16::And { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:337:44
[INFO] [stdout]     |
[INFO] [stdout] 337 |                 instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 337 -                 instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 337 +                 instructions8::Sub { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 -                 instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 337 +                 instructions8::Sub { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:339:45
[INFO] [stdout]     |
[INFO] [stdout] 339 |                 instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 339 -                 instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 339 +                 instructions16::Sub { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 339 -                 instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 339 +                 instructions16::Sub { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:341:44
[INFO] [stdout]     |
[INFO] [stdout] 341 |                 instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 341 -                 instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 341 +                 instructions8::Sub { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 341 -                 instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 341 +                 instructions8::Sub { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:343:45
[INFO] [stdout]     |
[INFO] [stdout] 343 |                 instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -                 instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 343 +                 instructions16::Sub { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -                 instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 343 +                 instructions16::Sub { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:350:44
[INFO] [stdout]     |
[INFO] [stdout] 350 |                 instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 350 -                 instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 350 +                 instructions8::Xor { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 350 -                 instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 350 +                 instructions8::Xor { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:352:45
[INFO] [stdout]     |
[INFO] [stdout] 352 |                 instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 352 -                 instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 352 +                 instructions16::Xor { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 352 -                 instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 352 +                 instructions16::Xor { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:354:44
[INFO] [stdout]     |
[INFO] [stdout] 354 |                 instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 354 -                 instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 354 +                 instructions8::Xor { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 -                 instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 354 +                 instructions8::Xor { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:356:45
[INFO] [stdout]     |
[INFO] [stdout] 356 |                 instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 356 -                 instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 356 +                 instructions16::Xor { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 -                 instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 356 +                 instructions16::Xor { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:378:44
[INFO] [stdout]     |
[INFO] [stdout] 378 |                 instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 378 -                 instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(),
[INFO] [stdout] 378 +                 instructions::Arpl { dest: modrm.effective(), src: modrm.register().into() } .into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 378 -                 instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(),
[INFO] [stdout] 378 +                 instructions::Arpl { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() } .into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:382:24
[INFO] [stdout]     |
[INFO] [stdout] 382 |                 dest1: modrm.register().into(),
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 382 -                 dest1: modrm.register().into(),
[INFO] [stdout] 382 +                 dest1: modrm.register(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 -                 dest1: modrm.register().into(),
[INFO] [stdout] 382 +                 dest1: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:388:24
[INFO] [stdout]     |
[INFO] [stdout] 388 |                 dest1: modrm.register().into(),
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 388 -                 dest1: modrm.register().into(),
[INFO] [stdout] 388 +                 dest1: modrm.register(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 -                 dest1: modrm.register().into(),
[INFO] [stdout] 388 +                 dest1: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:397:45
[INFO] [stdout]     |
[INFO] [stdout] 397 |                 instructions8::Jo { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 397 -                 instructions8::Jo { offset: offset.into() }.into(),
[INFO] [stdout] 397 +                 instructions8::Jo { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 397 -                 instructions8::Jo { offset: offset.into() }.into(),
[INFO] [stdout] 397 +                 instructions8::Jo { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:399:46
[INFO] [stdout]     |
[INFO] [stdout] 399 |                 instructions8::Jno { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 399 -                 instructions8::Jno { offset: offset.into() }.into(),
[INFO] [stdout] 399 +                 instructions8::Jno { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 399 -                 instructions8::Jno { offset: offset.into() }.into(),
[INFO] [stdout] 399 +                 instructions8::Jno { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:401:45
[INFO] [stdout]     |
[INFO] [stdout] 401 |                 instructions8::Jb { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 401 -                 instructions8::Jb { offset: offset.into() }.into(),
[INFO] [stdout] 401 +                 instructions8::Jb { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 -                 instructions8::Jb { offset: offset.into() }.into(),
[INFO] [stdout] 401 +                 instructions8::Jb { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:403:46
[INFO] [stdout]     |
[INFO] [stdout] 403 |                 instructions8::Jae { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 403 -                 instructions8::Jae { offset: offset.into() }.into(),
[INFO] [stdout] 403 +                 instructions8::Jae { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 403 -                 instructions8::Jae { offset: offset.into() }.into(),
[INFO] [stdout] 403 +                 instructions8::Jae { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:405:45
[INFO] [stdout]     |
[INFO] [stdout] 405 |                 instructions8::Je { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 405 -                 instructions8::Je { offset: offset.into() }.into(),
[INFO] [stdout] 405 +                 instructions8::Je { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 405 -                 instructions8::Je { offset: offset.into() }.into(),
[INFO] [stdout] 405 +                 instructions8::Je { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:407:46
[INFO] [stdout]     |
[INFO] [stdout] 407 |                 instructions8::Jne { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 407 -                 instructions8::Jne { offset: offset.into() }.into(),
[INFO] [stdout] 407 +                 instructions8::Jne { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 407 -                 instructions8::Jne { offset: offset.into() }.into(),
[INFO] [stdout] 407 +                 instructions8::Jne { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:409:46
[INFO] [stdout]     |
[INFO] [stdout] 409 |                 instructions8::Jbe { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 409 -                 instructions8::Jbe { offset: offset.into() }.into(),
[INFO] [stdout] 409 +                 instructions8::Jbe { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 409 -                 instructions8::Jbe { offset: offset.into() }.into(),
[INFO] [stdout] 409 +                 instructions8::Jbe { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:411:45
[INFO] [stdout]     |
[INFO] [stdout] 411 |                 instructions8::Ja { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 instructions8::Ja { offset: offset.into() }.into(),
[INFO] [stdout] 411 +                 instructions8::Ja { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 instructions8::Ja { offset: offset.into() }.into(),
[INFO] [stdout] 411 +                 instructions8::Ja { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:413:45
[INFO] [stdout]     |
[INFO] [stdout] 413 |                 instructions8::Js { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 413 -                 instructions8::Js { offset: offset.into() }.into(),
[INFO] [stdout] 413 +                 instructions8::Js { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 413 -                 instructions8::Js { offset: offset.into() }.into(),
[INFO] [stdout] 413 +                 instructions8::Js { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:415:46
[INFO] [stdout]     |
[INFO] [stdout] 415 |                 instructions8::Jns { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 415 -                 instructions8::Jns { offset: offset.into() }.into(),
[INFO] [stdout] 415 +                 instructions8::Jns { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 -                 instructions8::Jns { offset: offset.into() }.into(),
[INFO] [stdout] 415 +                 instructions8::Jns { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:417:45
[INFO] [stdout]     |
[INFO] [stdout] 417 |                 instructions8::Jp { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 417 -                 instructions8::Jp { offset: offset.into() }.into(),
[INFO] [stdout] 417 +                 instructions8::Jp { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 417 -                 instructions8::Jp { offset: offset.into() }.into(),
[INFO] [stdout] 417 +                 instructions8::Jp { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:419:46
[INFO] [stdout]     |
[INFO] [stdout] 419 |                 instructions8::Jnp { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 419 -                 instructions8::Jnp { offset: offset.into() }.into(),
[INFO] [stdout] 419 +                 instructions8::Jnp { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 419 -                 instructions8::Jnp { offset: offset.into() }.into(),
[INFO] [stdout] 419 +                 instructions8::Jnp { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:421:45
[INFO] [stdout]     |
[INFO] [stdout] 421 |                 instructions8::Jl { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 instructions8::Jl { offset: offset.into() }.into(),
[INFO] [stdout] 421 +                 instructions8::Jl { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 instructions8::Jl { offset: offset.into() }.into(),
[INFO] [stdout] 421 +                 instructions8::Jl { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:423:46
[INFO] [stdout]     |
[INFO] [stdout] 423 |                 instructions8::Jge { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 423 -                 instructions8::Jge { offset: offset.into() }.into(),
[INFO] [stdout] 423 +                 instructions8::Jge { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 423 -                 instructions8::Jge { offset: offset.into() }.into(),
[INFO] [stdout] 423 +                 instructions8::Jge { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:425:46
[INFO] [stdout]     |
[INFO] [stdout] 425 |                 instructions8::Jle { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 425 -                 instructions8::Jle { offset: offset.into() }.into(),
[INFO] [stdout] 425 +                 instructions8::Jle { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 425 -                 instructions8::Jle { offset: offset.into() }.into(),
[INFO] [stdout] 425 +                 instructions8::Jle { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:427:45
[INFO] [stdout]     |
[INFO] [stdout] 427 |                 instructions8::Jg { offset: offset.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 427 -                 instructions8::Jg { offset: offset.into() }.into(),
[INFO] [stdout] 427 +                 instructions8::Jg { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 427 -                 instructions8::Jg { offset: offset.into() }.into(),
[INFO] [stdout] 427 +                 instructions8::Jg { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:433:42
[INFO] [stdout]     |
[INFO] [stdout] 433 |                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 433 -                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 433 +                 instructions8::Xchg { a: modrm.effective(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 433 -                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 433 +                 instructions8::Xchg { a: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), b: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:433:71
[INFO] [stdout]     |
[INFO] [stdout] 433 |                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |                                                                       ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 433 -                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 433 +                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 433 -                 instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 433 +                 instructions8::Xchg { a: modrm.effective().into(), b: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:435:43
[INFO] [stdout]     |
[INFO] [stdout] 435 |                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 435 -                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 435 +                 instructions16::Xchg { a: modrm.effective(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 435 -                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 435 +                 instructions16::Xchg { a: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), b: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:435:72
[INFO] [stdout]     |
[INFO] [stdout] 435 |                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 435 -                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 435 +                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 435 -                 instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(),
[INFO] [stdout] 435 +                 instructions16::Xchg { a: modrm.effective().into(), b: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:437:44
[INFO] [stdout]     |
[INFO] [stdout] 437 |                 instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 437 -                 instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 437 +                 instructions8::Mov { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 437 -                 instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 437 +                 instructions8::Mov { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:439:45
[INFO] [stdout]     |
[INFO] [stdout] 439 |                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 439 -                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 439 +                 instructions16::Mov { dest: modrm.effective(), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 439 -                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(),
[INFO] [stdout] 439 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:441:44
[INFO] [stdout]     |
[INFO] [stdout] 441 |                 instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 441 +                 instructions8::Mov { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 441 +                 instructions8::Mov { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:443:45
[INFO] [stdout]     |
[INFO] [stdout] 443 |                 instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 443 -                 instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 443 +                 instructions16::Mov { dest: modrm.register(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 443 -                 instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 443 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:445:45
[INFO] [stdout]     |
[INFO] [stdout] 445 |                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 445 -                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout] 445 +                 instructions16::Mov { dest: modrm.effective(), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 -                 instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout] 445 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: modrm.segment_register()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:446:64
[INFO] [stdout]     |
[INFO] [stdout] 446 |             [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(),
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 446 -             [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(),
[INFO] [stdout] 446 +             [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register(), src: modrm.memory()? }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 446 -             [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(),
[INFO] [stdout] 446 +             [0x8D, modrm @ ModRM] => instructions::Lea { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()? }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:448:45
[INFO] [stdout]     |
[INFO] [stdout] 448 |                 instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 448 -                 instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 448 +                 instructions16::Mov { dest: modrm.segment_register()?, src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 448 -                 instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(),
[INFO] [stdout] 448 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.segment_register()?), src: modrm.effective().into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:450:45
[INFO] [stdout]     |
[INFO] [stdout] 450 |                 instructions16::Pop { dest: modrm.effective().into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 450 -                 instructions16::Pop { dest: modrm.effective().into() }.into(),
[INFO] [stdout] 450 +                 instructions16::Pop { dest: modrm.effective() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 450 -                 instructions16::Pop { dest: modrm.effective().into() }.into(),
[INFO] [stdout] 450 +                 instructions16::Pop { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/disasm/decoder.rs:484:48
[INFO] [stdout]     |
[INFO] [stdout] 484 |                 instructions::RetNear { count: count.into() }.into(),
[INFO] [stdout]     |                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 484 -                 instructions::RetNear { count: count.into() }.into(),
[INFO] [stdout] 484 +                 instructions::RetNear { count: count }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 484 -                 instructions::RetNear { count: count.into() }.into(),
[INFO] [stdout] 484 +                 instructions::RetNear { count: <u16 as Into<_>>::into(count) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:487:43
[INFO] [stdout]     |
[INFO] [stdout] 487 |                 instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 487 -                 instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 487 +                 instructions::Les { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 -                 instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 487 +                 instructions::Les { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:489:43
[INFO] [stdout]     |
[INFO] [stdout] 489 |                 instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 489 -                 instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 489 +                 instructions::Lds { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 489 -                 instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 489 +                 instructions::Lds { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:491:44
[INFO] [stdout]     |
[INFO] [stdout] 491 |                 instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 491 -                 instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout] 491 +                 instructions8::Mov { dest: modrm.effective(), src: src.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 491 -                 instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout] 491 +                 instructions8::Mov { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(modrm.effective()), src: src.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:493:45
[INFO] [stdout]     |
[INFO] [stdout] 493 |                 instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 493 -                 instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout] 493 +                 instructions16::Mov { dest: modrm.effective(), src: src.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 -                 instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(),
[INFO] [stdout] 493 +                 instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.effective()), src: src.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/disasm/decoder.rs:495:47
[INFO] [stdout]     |
[INFO] [stdout] 495 |                 instructions::RetFar { count: count.into() }.into(),
[INFO] [stdout]     |                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 495 -                 instructions::RetFar { count: count.into() }.into(),
[INFO] [stdout] 495 +                 instructions::RetFar { count: count }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 495 -                 instructions::RetFar { count: count.into() }.into(),
[INFO] [stdout] 495 +                 instructions::RetFar { count: <u16 as Into<_>>::into(count) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:509:47
[INFO] [stdout]     |
[INFO] [stdout] 509 |                 instructions::Loope { offset: offset.into() }.into(),
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 509 -                 instructions::Loope { offset: offset.into() }.into(),
[INFO] [stdout] 509 +                 instructions::Loope { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 509 -                 instructions::Loope { offset: offset.into() }.into(),
[INFO] [stdout] 509 +                 instructions::Loope { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:511:46
[INFO] [stdout]     |
[INFO] [stdout] 511 |                 instructions::Loop { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 511 -                 instructions::Loop { offset: offset.into() }.into(),
[INFO] [stdout] 511 +                 instructions::Loop { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 511 -                 instructions::Loop { offset: offset.into() }.into(),
[INFO] [stdout] 511 +                 instructions::Loop { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:513:46
[INFO] [stdout]     |
[INFO] [stdout] 513 |                 instructions::Jcxz { offset: offset.into() }.into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 513 -                 instructions::Jcxz { offset: offset.into() }.into(),
[INFO] [stdout] 513 +                 instructions::Jcxz { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 513 -                 instructions::Jcxz { offset: offset.into() }.into(),
[INFO] [stdout] 513 +                 instructions::Jcxz { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:523:49
[INFO] [stdout]     |
[INFO] [stdout] 523 |                 instructions::CallRel { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 523 -                 instructions::CallRel { offset: offset.into() }.into(),
[INFO] [stdout] 523 +                 instructions::CallRel { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 -                 instructions::CallRel { offset: offset.into() }.into(),
[INFO] [stdout] 523 +                 instructions::CallRel { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:525:50
[INFO] [stdout]     |
[INFO] [stdout] 525 |                 instructions16::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 525 -                 instructions16::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout] 525 +                 instructions16::JmpRel { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 525 -                 instructions16::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout] 525 +                 instructions16::JmpRel { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]    --> src/disasm/decoder.rs:529:49
[INFO] [stdout]     |
[INFO] [stdout] 529 |                 instructions8::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 529 -                 instructions8::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout] 529 +                 instructions8::JmpRel { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 529 -                 instructions8::JmpRel { offset: offset.into() }.into(),
[INFO] [stdout] 529 +                 instructions8::JmpRel { offset: <i8 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:554:66
[INFO] [stdout]     |
[INFO] [stdout] 554 |             [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 554 -             [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(),
[INFO] [stdout] 554 +             [0x80, offset @ i16] => instructions16::Jo { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 -             [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(),
[INFO] [stdout] 554 +             [0x80, offset @ i16] => instructions16::Jo { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:555:67
[INFO] [stdout]     |
[INFO] [stdout] 555 |             [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 555 -             [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(),
[INFO] [stdout] 555 +             [0x81, offset @ i16] => instructions16::Jno { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 555 -             [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(),
[INFO] [stdout] 555 +             [0x81, offset @ i16] => instructions16::Jno { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:556:66
[INFO] [stdout]     |
[INFO] [stdout] 556 |             [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 556 -             [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(),
[INFO] [stdout] 556 +             [0x82, offset @ i16] => instructions16::Jb { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 556 -             [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(),
[INFO] [stdout] 556 +             [0x82, offset @ i16] => instructions16::Jb { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:557:67
[INFO] [stdout]     |
[INFO] [stdout] 557 |             [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 557 -             [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(),
[INFO] [stdout] 557 +             [0x83, offset @ i16] => instructions16::Jae { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 557 -             [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(),
[INFO] [stdout] 557 +             [0x83, offset @ i16] => instructions16::Jae { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:558:66
[INFO] [stdout]     |
[INFO] [stdout] 558 |             [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 558 -             [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(),
[INFO] [stdout] 558 +             [0x84, offset @ i16] => instructions16::Je { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 558 -             [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(),
[INFO] [stdout] 558 +             [0x84, offset @ i16] => instructions16::Je { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:559:67
[INFO] [stdout]     |
[INFO] [stdout] 559 |             [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 559 -             [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(),
[INFO] [stdout] 559 +             [0x85, offset @ i16] => instructions16::Jne { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 559 -             [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(),
[INFO] [stdout] 559 +             [0x85, offset @ i16] => instructions16::Jne { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:560:67
[INFO] [stdout]     |
[INFO] [stdout] 560 |             [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 560 -             [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(),
[INFO] [stdout] 560 +             [0x86, offset @ i16] => instructions16::Jbe { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 560 -             [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(),
[INFO] [stdout] 560 +             [0x86, offset @ i16] => instructions16::Jbe { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:561:66
[INFO] [stdout]     |
[INFO] [stdout] 561 |             [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 561 -             [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(),
[INFO] [stdout] 561 +             [0x87, offset @ i16] => instructions16::Ja { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 561 -             [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(),
[INFO] [stdout] 561 +             [0x87, offset @ i16] => instructions16::Ja { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:562:66
[INFO] [stdout]     |
[INFO] [stdout] 562 |             [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 562 -             [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(),
[INFO] [stdout] 562 +             [0x88, offset @ i16] => instructions16::Js { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 562 -             [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(),
[INFO] [stdout] 562 +             [0x88, offset @ i16] => instructions16::Js { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:563:67
[INFO] [stdout]     |
[INFO] [stdout] 563 |             [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 563 -             [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(),
[INFO] [stdout] 563 +             [0x89, offset @ i16] => instructions16::Jns { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 563 -             [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(),
[INFO] [stdout] 563 +             [0x89, offset @ i16] => instructions16::Jns { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:564:66
[INFO] [stdout]     |
[INFO] [stdout] 564 |             [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 564 -             [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(),
[INFO] [stdout] 564 +             [0x8A, offset @ i16] => instructions16::Jp { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 564 -             [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(),
[INFO] [stdout] 564 +             [0x8A, offset @ i16] => instructions16::Jp { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:565:67
[INFO] [stdout]     |
[INFO] [stdout] 565 |             [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 565 -             [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(),
[INFO] [stdout] 565 +             [0x8B, offset @ i16] => instructions16::Jnp { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 565 -             [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(),
[INFO] [stdout] 565 +             [0x8B, offset @ i16] => instructions16::Jnp { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:566:66
[INFO] [stdout]     |
[INFO] [stdout] 566 |             [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 566 -             [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(),
[INFO] [stdout] 566 +             [0x8C, offset @ i16] => instructions16::Jl { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 566 -             [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(),
[INFO] [stdout] 566 +             [0x8C, offset @ i16] => instructions16::Jl { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:567:67
[INFO] [stdout]     |
[INFO] [stdout] 567 |             [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 567 -             [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(),
[INFO] [stdout] 567 +             [0x8D, offset @ i16] => instructions16::Jge { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 567 -             [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(),
[INFO] [stdout] 567 +             [0x8D, offset @ i16] => instructions16::Jge { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:568:67
[INFO] [stdout]     |
[INFO] [stdout] 568 |             [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 568 -             [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(),
[INFO] [stdout] 568 +             [0x8E, offset @ i16] => instructions16::Jle { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 568 -             [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(),
[INFO] [stdout] 568 +             [0x8E, offset @ i16] => instructions16::Jle { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]    --> src/disasm/decoder.rs:569:66
[INFO] [stdout]     |
[INFO] [stdout] 569 |             [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(),
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 569 -             [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(),
[INFO] [stdout] 569 +             [0x8F, offset @ i16] => instructions16::Jg { offset: offset }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 569 -             [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(),
[INFO] [stdout] 569 +             [0x8F, offset @ i16] => instructions16::Jg { offset: <i16 as Into<_>>::into(offset) }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:576:24
[INFO] [stdout]     |
[INFO] [stdout] 576 |                 dest1: modrm.register().into(),
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 576 -                 dest1: modrm.register().into(),
[INFO] [stdout] 576 +                 dest1: modrm.register(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 576 -                 dest1: modrm.register().into(),
[INFO] [stdout] 576 +                 dest1: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:582:43
[INFO] [stdout]     |
[INFO] [stdout] 582 |                 instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 582 -                 instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 582 +                 instructions::Lss { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 582 -                 instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 582 +                 instructions::Lss { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:584:43
[INFO] [stdout]     |
[INFO] [stdout] 584 |                 instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 584 -                 instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 584 +                 instructions::Lfs { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 584 -                 instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 584 +                 instructions::Lfs { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:586:43
[INFO] [stdout]     |
[INFO] [stdout] 586 |                 instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 586 -                 instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 586 +                 instructions::Lgs { dest: modrm.register(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 586 -                 instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(),
[INFO] [stdout] 586 +                 instructions::Lgs { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:757:55
[INFO] [stdout]     |
[INFO] [stdout] 757 |                 return Ok(instructions16::Inc { dest: reg.into() }.into());
[INFO] [stdout]     |                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 757 -                 return Ok(instructions16::Inc { dest: reg.into() }.into());
[INFO] [stdout] 757 +                 return Ok(instructions16::Inc { dest: reg }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 757 -                 return Ok(instructions16::Inc { dest: reg.into() }.into());
[INFO] [stdout] 757 +                 return Ok(instructions16::Inc { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg) }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:761:55
[INFO] [stdout]     |
[INFO] [stdout] 761 |                 return Ok(instructions16::Dec { dest: reg.into() }.into());
[INFO] [stdout]     |                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 761 -                 return Ok(instructions16::Dec { dest: reg.into() }.into());
[INFO] [stdout] 761 +                 return Ok(instructions16::Dec { dest: reg }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 761 -                 return Ok(instructions16::Dec { dest: reg.into() }.into());
[INFO] [stdout] 761 +                 return Ok(instructions16::Dec { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg) }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:769:55
[INFO] [stdout]     |
[INFO] [stdout] 769 |                 return Ok(instructions16::Pop { dest: reg.into() }.into());
[INFO] [stdout]     |                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 769 -                 return Ok(instructions16::Pop { dest: reg.into() }.into());
[INFO] [stdout] 769 +                 return Ok(instructions16::Pop { dest: reg }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 769 -                 return Ok(instructions16::Pop { dest: reg.into() }.into());
[INFO] [stdout] 769 +                 return Ok(instructions16::Pop { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg) }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:778:79
[INFO] [stdout]     |
[INFO] [stdout] 778 |                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into());
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 778 -                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into());
[INFO] [stdout] 778 +                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 778 -                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into());
[INFO] [stdout] 778 +                 return Ok(instructions16::Xchg { a: Register16::AX.into(), b: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg) }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size8>`
[INFO] [stdout]    --> src/disasm/decoder.rs:785:54
[INFO] [stdout]     |
[INFO] [stdout] 785 |                 return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout]     |                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 785 -                 return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout] 785 +                 return Ok(instructions8::Mov { dest: reg, src: imm.into() }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 785 -                 return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout] 785 +                 return Ok(instructions8::Mov { dest: <instruction::MutOperand<instruction::Size8> as Into<_>>::into(reg), src: imm.into() }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand<instruction::Size16>`
[INFO] [stdout]    --> src/disasm/decoder.rs:790:55
[INFO] [stdout]     |
[INFO] [stdout] 790 |                 return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout]     |                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 790 -                 return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout] 790 +                 return Ok(instructions16::Mov { dest: reg, src: imm.into() }.into());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 790 -                 return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into());
[INFO] [stdout] 790 +                 return Ok(instructions16::Mov { dest: <instruction::MutOperand<instruction::Size16> as Into<_>>::into(reg), src: imm.into() }.into());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `emulator` (bin "emulator") due to 97 previous errors; 4 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", kill_on_drop: false }`
[INFO] [stdout] 2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668
