[INFO] cloning repository https://github.com/CaptFudgeCake/chip8
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/CaptFudgeCake/chip8" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaptFudgeCake%2Fchip8", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaptFudgeCake%2Fchip8'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] f5d01bf131d40c348d0c8a3c1b008f7e9d0dc6d3
[INFO] checking CaptFudgeCake/chip8 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaptFudgeCake%2Fchip8" "/workspace/builds/worker-5-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-5-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/CaptFudgeCake/chip8
[INFO] finished tweaking git repo https://github.com/CaptFudgeCake/chip8
[INFO] tweaked toml for git repo https://github.com/CaptFudgeCake/chip8 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/CaptFudgeCake/chip8 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/CaptFudgeCake/chip8 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9
[INFO] running `Command { std: "docker" "start" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", 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" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", 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" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.153
[INFO] [stderr]    Compiling autocfg v1.1.0
[INFO] [stderr]     Checking cfg-if v1.0.0
[INFO] [stderr]    Compiling cfg_aliases v0.1.1
[INFO] [stderr]    Compiling signal-hook v0.3.17
[INFO] [stderr]    Compiling parking_lot_core v0.9.9
[INFO] [stderr]     Checking scopeguard v1.2.0
[INFO] [stderr]     Checking log v0.4.21
[INFO] [stderr]     Checking smallvec v1.13.1
[INFO] [stderr]     Checking bitflags v2.4.2
[INFO] [stderr]    Compiling nix v0.28.0
[INFO] [stderr]    Compiling lock_api v0.4.11
[INFO] [stderr]     Checking signal-hook-registry v1.4.1
[INFO] [stderr]     Checking mio v0.8.11
[INFO] [stderr]     Checking parking_lot v0.12.1
[INFO] [stderr]     Checking signal-hook-mio v0.2.3
[INFO] [stderr]     Checking crossterm v0.27.0
[INFO] [stderr]     Checking ctrlc v3.4.4
[INFO] [stderr]     Checking chip8 v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: unused import: `super::*`
[INFO] [stdout]    --> src/main.rs:137:9
[INFO] [stdout]     |
[INFO] [stdout] 137 |     use super::*;
[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 import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/add.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::Chip8;
[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 import: `crate::commands::add::Add`
[INFO] [stdout]   --> src/commands/add.rs:29:9
[INFO] [stdout]    |
[INFO] [stdout] 29 |     use crate::commands::add::Add;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/add.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/add_to_index.rs:22:9
[INFO] [stdout]    |
[INFO] [stdout] 22 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::add_to_index::AddToIndex`
[INFO] [stdout]   --> src/commands/add_to_index.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::commands::add_to_index::AddToIndex;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/add_to_index.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/add_value_to_register.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::add_value_to_register::AddValueToRegister`
[INFO] [stdout]   --> src/commands/add_value_to_register.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     use crate::commands::add_value_to_register::AddValueToRegister;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/add_value_to_register.rs:25:9
[INFO] [stdout]    |
[INFO] [stdout] 25 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/and.rs:26:9
[INFO] [stdout]    |
[INFO] [stdout] 26 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::and::And`
[INFO] [stdout]   --> src/commands/and.rs:27:9
[INFO] [stdout]    |
[INFO] [stdout] 27 |     use crate::commands::and::And;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/and.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/binary_coded_decimal.rs:26:9
[INFO] [stdout]    |
[INFO] [stdout] 26 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::binary_coded_decimal::BinaryCodedDecimal`
[INFO] [stdout]   --> src/commands/binary_coded_decimal.rs:27:9
[INFO] [stdout]    |
[INFO] [stdout] 27 |     use crate::commands::binary_coded_decimal::BinaryCodedDecimal;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/binary_coded_decimal.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/call.rs:22:9
[INFO] [stdout]    |
[INFO] [stdout] 22 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::call::Call`
[INFO] [stdout]   --> src/commands/call.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::commands::call::Call;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/call.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/clear_screen.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::clear_screen::ClearScreen`
[INFO] [stdout]   --> src/commands/clear_screen.rs:25:9
[INFO] [stdout]    |
[INFO] [stdout] 25 |     use crate::commands::clear_screen::ClearScreen;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/clear_screen.rs:26:9
[INFO] [stdout]    |
[INFO] [stdout] 26 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/draw.rs:44:9
[INFO] [stdout]    |
[INFO] [stdout] 44 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/draw.rs:45:9
[INFO] [stdout]    |
[INFO] [stdout] 45 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::draw::Draw`
[INFO] [stdout]   --> src/commands/draw.rs:46:9
[INFO] [stdout]    |
[INFO] [stdout] 46 |     use crate::commands::draw::Draw;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/jump.rs:21:9
[INFO] [stdout]    |
[INFO] [stdout] 21 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/jump.rs:22:9
[INFO] [stdout]    |
[INFO] [stdout] 22 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::jump::Jump`
[INFO] [stdout]   --> src/commands/jump.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::commands::jump::Jump;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/load.rs:25:9
[INFO] [stdout]    |
[INFO] [stdout] 25 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/load.rs:26:9
[INFO] [stdout]    |
[INFO] [stdout] 26 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::load::Load`
[INFO] [stdout]   --> src/commands/load.rs:27:9
[INFO] [stdout]    |
[INFO] [stdout] 27 |     use crate::commands::load::Load;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/or.rs:26:9
[INFO] [stdout]    |
[INFO] [stdout] 26 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/or.rs:27:9
[INFO] [stdout]    |
[INFO] [stdout] 27 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::or::Or`
[INFO] [stdout]   --> src/commands/or.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::commands::or::Or;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/read_into_registers.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/read_into_registers.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::read_into_registers::ReadIntoRegisters`
[INFO] [stdout]   --> src/commands/read_into_registers.rs:25:9
[INFO] [stdout]    |
[INFO] [stdout] 25 |     use crate::commands::read_into_registers::ReadIntoRegisters;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/return_command.rs:22:9
[INFO] [stdout]    |
[INFO] [stdout] 22 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/return_command.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::return_command::Return`
[INFO] [stdout]   --> src/commands/return_command.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     use crate::commands::return_command::Return;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/set_index_register.rs:21:9
[INFO] [stdout]    |
[INFO] [stdout] 21 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/set_index_register.rs:22:9
[INFO] [stdout]    |
[INFO] [stdout] 22 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::set_index_register::SetIndexRegister`
[INFO] [stdout]   --> src/commands/set_index_register.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::commands::set_index_register::SetIndexRegister;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/set_register.rs:22:9
[INFO] [stdout]    |
[INFO] [stdout] 22 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/set_register.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::set_register::SetRegister`
[INFO] [stdout]   --> src/commands/set_register.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     use crate::commands::set_register::SetRegister;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/shift_left.rs:33:9
[INFO] [stdout]    |
[INFO] [stdout] 33 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/shift_left.rs:34:9
[INFO] [stdout]    |
[INFO] [stdout] 34 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::shift_left::ShiftLeft`
[INFO] [stdout]   --> src/commands/shift_left.rs:35:9
[INFO] [stdout]    |
[INFO] [stdout] 35 |     use crate::commands::shift_left::ShiftLeft;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/shift_right.rs:33:9
[INFO] [stdout]    |
[INFO] [stdout] 33 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/shift_right.rs:34:9
[INFO] [stdout]    |
[INFO] [stdout] 34 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::shift_right::ShiftRight`
[INFO] [stdout]   --> src/commands/shift_right.rs:35:9
[INFO] [stdout]    |
[INFO] [stdout] 35 |     use crate::commands::shift_right::ShiftRight;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/skip_equal_x.rs:26:9
[INFO] [stdout]    |
[INFO] [stdout] 26 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/skip_equal_x.rs:27:9
[INFO] [stdout]    |
[INFO] [stdout] 27 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::skip_equal_x::SkipEqualX`
[INFO] [stdout]   --> src/commands/skip_equal_x.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::commands::skip_equal_x::SkipEqualX;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/skip_equal_x_y.rs:29:9
[INFO] [stdout]    |
[INFO] [stdout] 29 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/skip_equal_x_y.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::skip_equal_x_y::SkipEqualXY`
[INFO] [stdout]   --> src/commands/skip_equal_x_y.rs:31:9
[INFO] [stdout]    |
[INFO] [stdout] 31 |     use crate::commands::skip_equal_x_y::SkipEqualXY;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/skip_not_equal_x.rs:27:9
[INFO] [stdout]    |
[INFO] [stdout] 27 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/skip_not_equal_x.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::skip_not_equal_x::SkipNotEqualX`
[INFO] [stdout]   --> src/commands/skip_not_equal_x.rs:29:9
[INFO] [stdout]    |
[INFO] [stdout] 29 |     use crate::commands::skip_not_equal_x::SkipNotEqualX;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/skip_not_equal_xy.rs:29:9
[INFO] [stdout]    |
[INFO] [stdout] 29 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/skip_not_equal_xy.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::skip_not_equal_xy::SkipNotEqualXY`
[INFO] [stdout]   --> src/commands/skip_not_equal_xy.rs:31:9
[INFO] [stdout]    |
[INFO] [stdout] 31 |     use crate::commands::skip_not_equal_xy::SkipNotEqualXY;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/store_registers.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/store_registers.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::store_registers::StoreRegisters`
[INFO] [stdout]   --> src/commands/store_registers.rs:25:9
[INFO] [stdout]    |
[INFO] [stdout] 25 |     use crate::commands::store_registers::StoreRegisters;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/sub.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/sub.rs:29:9
[INFO] [stdout]    |
[INFO] [stdout] 29 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::sub::Sub`
[INFO] [stdout]   --> src/commands/sub.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |     use crate::commands::sub::Sub;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/sub_n.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/sub_n.rs:29:9
[INFO] [stdout]    |
[INFO] [stdout] 29 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::sub_n::SubN`
[INFO] [stdout]   --> src/commands/sub_n.rs:30:9
[INFO] [stdout]    |
[INFO] [stdout] 30 |     use crate::commands::sub_n::SubN;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::Chip8`
[INFO] [stdout]   --> src/commands/xor.rs:26:9
[INFO] [stdout]    |
[INFO] [stdout] 26 |     use crate::Chip8;
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::command::Command`
[INFO] [stdout]   --> src/commands/xor.rs:27:9
[INFO] [stdout]    |
[INFO] [stdout] 27 |     use crate::commands::command::Command;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::commands::xor::Xor`
[INFO] [stdout]   --> src/commands/xor.rs:28:9
[INFO] [stdout]    |
[INFO] [stdout] 28 |     use crate::commands::xor::Xor;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field `sound_timer` is never read
[INFO] [stdout]   --> src/main.rs:25:5
[INFO] [stdout]    |
[INFO] [stdout] 18 | struct Chip8 {
[INFO] [stdout]    |        ----- field in this struct
[INFO] [stdout] ...
[INFO] [stdout] 25 |     sound_timer: u8,
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: enum `Chip8Commands` is never used
[INFO] [stdout]  --> src/chip8_commands.rs:2:17
[INFO] [stdout]   |
[INFO] [stdout] 2 | pub(crate) enum Chip8Commands {
[INFO] [stdout]   |                 ^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: associated function `new` is never used
[INFO] [stdout]   --> src/chip8_commands.rs:31:12
[INFO] [stdout]    |
[INFO] [stdout] 30 | impl Chip8Commands {
[INFO] [stdout]    | ------------------ associated function in this implementation
[INFO] [stdout] 31 |     pub fn new(command: &[u8]) -> Chip8Commands {
[INFO] [stdout]    |            ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: associated function `new` is never used
[INFO] [stdout]  --> src/commands/clear_screen.rs:7:12
[INFO] [stdout]   |
[INFO] [stdout] 6 | impl ClearScreen {
[INFO] [stdout]   | ---------------- associated function in this implementation
[INFO] [stdout] 7 |     pub fn new() -> Self {
[INFO] [stdout]   |            ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: associated function `new` is never used
[INFO] [stdout]  --> src/commands/return_command.rs:7:12
[INFO] [stdout]   |
[INFO] [stdout] 6 | impl Return {
[INFO] [stdout]   | ----------- associated function in this implementation
[INFO] [stdout] 7 |     pub fn new() -> Self {
[INFO] [stdout]   |            ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:42:52
[INFO] [stdout]    |
[INFO] [stdout] 42 |                     3 => Chip8Commands::SkipEqualX(x.into(), command[1]),
[INFO] [stdout]    |                                                    ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -                     3 => Chip8Commands::SkipEqualX(x.into(), command[1]),
[INFO] [stdout] 42 +                     3 => Chip8Commands::SkipEqualX(x, command[1]),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -                     3 => Chip8Commands::SkipEqualX(x.into(), command[1]),
[INFO] [stdout] 42 +                     3 => Chip8Commands::SkipEqualX(<u8 as Into<_>>::into(x), command[1]),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:43:55
[INFO] [stdout]    |
[INFO] [stdout] 43 |                     4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]),
[INFO] [stdout]    |                                                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 43 -                     4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]),
[INFO] [stdout] 43 +                     4 => Chip8Commands::SkipNotEqualX(x, command[1]),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 -                     4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]),
[INFO] [stdout] 43 +                     4 => Chip8Commands::SkipNotEqualX(<u8 as Into<_>>::into(x), command[1]),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:44:53
[INFO] [stdout]    |
[INFO] [stdout] 44 |                     6 => Chip8Commands::SetRegister(x.into(), command[1]),
[INFO] [stdout]    |                                                     ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 44 -                     6 => Chip8Commands::SetRegister(x.into(), command[1]),
[INFO] [stdout] 44 +                     6 => Chip8Commands::SetRegister(x, command[1]),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 -                     6 => Chip8Commands::SetRegister(x.into(), command[1]),
[INFO] [stdout] 44 +                     6 => Chip8Commands::SetRegister(<u8 as Into<_>>::into(x), command[1]),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:45:60
[INFO] [stdout]    |
[INFO] [stdout] 45 |                     7 => Chip8Commands::AddValueToRegister(x.into(), command[1]),
[INFO] [stdout]    |                                                            ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 45 -                     7 => Chip8Commands::AddValueToRegister(x.into(), command[1]),
[INFO] [stdout] 45 +                     7 => Chip8Commands::AddValueToRegister(x, command[1]),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 45 -                     7 => Chip8Commands::AddValueToRegister(x.into(), command[1]),
[INFO] [stdout] 45 +                     7 => Chip8Commands::AddValueToRegister(<u8 as Into<_>>::into(x), command[1]),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:54:48
[INFO] [stdout]    |
[INFO] [stdout] 54 |                     0x0 => Chip8Commands::Load(x.into(), y.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] 54 -                     0x0 => Chip8Commands::Load(x.into(), y.into()),
[INFO] [stdout] 54 +                     0x0 => Chip8Commands::Load(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -                     0x0 => Chip8Commands::Load(x.into(), y.into()),
[INFO] [stdout] 54 +                     0x0 => Chip8Commands::Load(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:54:58
[INFO] [stdout]    |
[INFO] [stdout] 54 |                     0x0 => Chip8Commands::Load(x.into(), y.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] 54 -                     0x0 => Chip8Commands::Load(x.into(), y.into()),
[INFO] [stdout] 54 +                     0x0 => Chip8Commands::Load(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -                     0x0 => Chip8Commands::Load(x.into(), y.into()),
[INFO] [stdout] 54 +                     0x0 => Chip8Commands::Load(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:55:46
[INFO] [stdout]    |
[INFO] [stdout] 55 |                     0x1 => Chip8Commands::OR(x.into(), y.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] 55 -                     0x1 => Chip8Commands::OR(x.into(), y.into()),
[INFO] [stdout] 55 +                     0x1 => Chip8Commands::OR(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                     0x1 => Chip8Commands::OR(x.into(), y.into()),
[INFO] [stdout] 55 +                     0x1 => Chip8Commands::OR(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:55:56
[INFO] [stdout]    |
[INFO] [stdout] 55 |                     0x1 => Chip8Commands::OR(x.into(), y.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] 55 -                     0x1 => Chip8Commands::OR(x.into(), y.into()),
[INFO] [stdout] 55 +                     0x1 => Chip8Commands::OR(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                     0x1 => Chip8Commands::OR(x.into(), y.into()),
[INFO] [stdout] 55 +                     0x1 => Chip8Commands::OR(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:56:47
[INFO] [stdout]    |
[INFO] [stdout] 56 |                     0x2 => Chip8Commands::AND(x.into(), y.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] 56 -                     0x2 => Chip8Commands::AND(x.into(), y.into()),
[INFO] [stdout] 56 +                     0x2 => Chip8Commands::AND(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -                     0x2 => Chip8Commands::AND(x.into(), y.into()),
[INFO] [stdout] 56 +                     0x2 => Chip8Commands::AND(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:56:57
[INFO] [stdout]    |
[INFO] [stdout] 56 |                     0x2 => Chip8Commands::AND(x.into(), y.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] 56 -                     0x2 => Chip8Commands::AND(x.into(), y.into()),
[INFO] [stdout] 56 +                     0x2 => Chip8Commands::AND(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -                     0x2 => Chip8Commands::AND(x.into(), y.into()),
[INFO] [stdout] 56 +                     0x2 => Chip8Commands::AND(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:57:47
[INFO] [stdout]    |
[INFO] [stdout] 57 |                     0x3 => Chip8Commands::XOR(x.into(), y.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] 57 -                     0x3 => Chip8Commands::XOR(x.into(), y.into()),
[INFO] [stdout] 57 +                     0x3 => Chip8Commands::XOR(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -                     0x3 => Chip8Commands::XOR(x.into(), y.into()),
[INFO] [stdout] 57 +                     0x3 => Chip8Commands::XOR(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:57:57
[INFO] [stdout]    |
[INFO] [stdout] 57 |                     0x3 => Chip8Commands::XOR(x.into(), y.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] 57 -                     0x3 => Chip8Commands::XOR(x.into(), y.into()),
[INFO] [stdout] 57 +                     0x3 => Chip8Commands::XOR(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -                     0x3 => Chip8Commands::XOR(x.into(), y.into()),
[INFO] [stdout] 57 +                     0x3 => Chip8Commands::XOR(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:58:47
[INFO] [stdout]    |
[INFO] [stdout] 58 |                     0x4 => Chip8Commands::ADD(x.into(), y.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] 58 -                     0x4 => Chip8Commands::ADD(x.into(), y.into()),
[INFO] [stdout] 58 +                     0x4 => Chip8Commands::ADD(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -                     0x4 => Chip8Commands::ADD(x.into(), y.into()),
[INFO] [stdout] 58 +                     0x4 => Chip8Commands::ADD(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:58:57
[INFO] [stdout]    |
[INFO] [stdout] 58 |                     0x4 => Chip8Commands::ADD(x.into(), y.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] 58 -                     0x4 => Chip8Commands::ADD(x.into(), y.into()),
[INFO] [stdout] 58 +                     0x4 => Chip8Commands::ADD(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -                     0x4 => Chip8Commands::ADD(x.into(), y.into()),
[INFO] [stdout] 58 +                     0x4 => Chip8Commands::ADD(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:59:47
[INFO] [stdout]    |
[INFO] [stdout] 59 |                     0x5 => Chip8Commands::SUB(x.into(), y.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] 59 -                     0x5 => Chip8Commands::SUB(x.into(), y.into()),
[INFO] [stdout] 59 +                     0x5 => Chip8Commands::SUB(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -                     0x5 => Chip8Commands::SUB(x.into(), y.into()),
[INFO] [stdout] 59 +                     0x5 => Chip8Commands::SUB(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:59:57
[INFO] [stdout]    |
[INFO] [stdout] 59 |                     0x5 => Chip8Commands::SUB(x.into(), y.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] 59 -                     0x5 => Chip8Commands::SUB(x.into(), y.into()),
[INFO] [stdout] 59 +                     0x5 => Chip8Commands::SUB(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -                     0x5 => Chip8Commands::SUB(x.into(), y.into()),
[INFO] [stdout] 59 +                     0x5 => Chip8Commands::SUB(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:60:54
[INFO] [stdout]    |
[INFO] [stdout] 60 |                     0x6 => Chip8Commands::ShiftRight(x.into(), y.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] 60 -                     0x6 => Chip8Commands::ShiftRight(x.into(), y.into()),
[INFO] [stdout] 60 +                     0x6 => Chip8Commands::ShiftRight(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                     0x6 => Chip8Commands::ShiftRight(x.into(), y.into()),
[INFO] [stdout] 60 +                     0x6 => Chip8Commands::ShiftRight(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:60:64
[INFO] [stdout]    |
[INFO] [stdout] 60 |                     0x6 => Chip8Commands::ShiftRight(x.into(), y.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] 60 -                     0x6 => Chip8Commands::ShiftRight(x.into(), y.into()),
[INFO] [stdout] 60 +                     0x6 => Chip8Commands::ShiftRight(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                     0x6 => Chip8Commands::ShiftRight(x.into(), y.into()),
[INFO] [stdout] 60 +                     0x6 => Chip8Commands::ShiftRight(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:61:48
[INFO] [stdout]    |
[INFO] [stdout] 61 |                     0x7 => Chip8Commands::SUBN(x.into(), y.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] 61 -                     0x7 => Chip8Commands::SUBN(x.into(), y.into()),
[INFO] [stdout] 61 +                     0x7 => Chip8Commands::SUBN(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                     0x7 => Chip8Commands::SUBN(x.into(), y.into()),
[INFO] [stdout] 61 +                     0x7 => Chip8Commands::SUBN(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:61:58
[INFO] [stdout]    |
[INFO] [stdout] 61 |                     0x7 => Chip8Commands::SUBN(x.into(), y.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] 61 -                     0x7 => Chip8Commands::SUBN(x.into(), y.into()),
[INFO] [stdout] 61 +                     0x7 => Chip8Commands::SUBN(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                     0x7 => Chip8Commands::SUBN(x.into(), y.into()),
[INFO] [stdout] 61 +                     0x7 => Chip8Commands::SUBN(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:62:53
[INFO] [stdout]    |
[INFO] [stdout] 62 |                     0xE => Chip8Commands::ShiftLeft(x.into(), y.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] 62 -                     0xE => Chip8Commands::ShiftLeft(x.into(), y.into()),
[INFO] [stdout] 62 +                     0xE => Chip8Commands::ShiftLeft(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -                     0xE => Chip8Commands::ShiftLeft(x.into(), y.into()),
[INFO] [stdout] 62 +                     0xE => Chip8Commands::ShiftLeft(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:62:63
[INFO] [stdout]    |
[INFO] [stdout] 62 |                     0xE => Chip8Commands::ShiftLeft(x.into(), y.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] 62 -                     0xE => Chip8Commands::ShiftLeft(x.into(), y.into()),
[INFO] [stdout] 62 +                     0xE => Chip8Commands::ShiftLeft(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -                     0xE => Chip8Commands::ShiftLeft(x.into(), y.into()),
[INFO] [stdout] 62 +                     0xE => Chip8Commands::ShiftLeft(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:69:55
[INFO] [stdout]    |
[INFO] [stdout] 69 |                     0x1E => Chip8Commands::AddToIndex(x.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] 69 -                     0x1E => Chip8Commands::AddToIndex(x.into()),
[INFO] [stdout] 69 +                     0x1E => Chip8Commands::AddToIndex(x),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -                     0x1E => Chip8Commands::AddToIndex(x.into()),
[INFO] [stdout] 69 +                     0x1E => Chip8Commands::AddToIndex(<u8 as Into<_>>::into(x)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:70:63
[INFO] [stdout]    |
[INFO] [stdout] 70 |                     0x33 => Chip8Commands::BinaryCodedDecimal(x.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] 70 -                     0x33 => Chip8Commands::BinaryCodedDecimal(x.into()),
[INFO] [stdout] 70 +                     0x33 => Chip8Commands::BinaryCodedDecimal(x),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 -                     0x33 => Chip8Commands::BinaryCodedDecimal(x.into()),
[INFO] [stdout] 70 +                     0x33 => Chip8Commands::BinaryCodedDecimal(<u8 as Into<_>>::into(x)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:71:59
[INFO] [stdout]    |
[INFO] [stdout] 71 |                     0x55 => Chip8Commands::StoreRegisters(x.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] 71 -                     0x55 => Chip8Commands::StoreRegisters(x.into()),
[INFO] [stdout] 71 +                     0x55 => Chip8Commands::StoreRegisters(x),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 -                     0x55 => Chip8Commands::StoreRegisters(x.into()),
[INFO] [stdout] 71 +                     0x55 => Chip8Commands::StoreRegisters(<u8 as Into<_>>::into(x)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:72:62
[INFO] [stdout]    |
[INFO] [stdout] 72 |                     0x65 => Chip8Commands::ReadIntoRegisters(x.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] 72 -                     0x65 => Chip8Commands::ReadIntoRegisters(x.into()),
[INFO] [stdout] 72 +                     0x65 => Chip8Commands::ReadIntoRegisters(x),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 -                     0x65 => Chip8Commands::ReadIntoRegisters(x.into()),
[INFO] [stdout] 72 +                     0x65 => Chip8Commands::ReadIntoRegisters(<u8 as Into<_>>::into(x)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:88:44
[INFO] [stdout]    |
[INFO] [stdout] 88 |                 Chip8Commands::SkipEqualXY(x.into(), y.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] 88 -                 Chip8Commands::SkipEqualXY(x.into(), y.into())
[INFO] [stdout] 88 +                 Chip8Commands::SkipEqualXY(x, y.into())
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 -                 Chip8Commands::SkipEqualXY(x.into(), y.into())
[INFO] [stdout] 88 +                 Chip8Commands::SkipEqualXY(<u8 as Into<_>>::into(x), y.into())
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:88:54
[INFO] [stdout]    |
[INFO] [stdout] 88 |                 Chip8Commands::SkipEqualXY(x.into(), y.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] 88 -                 Chip8Commands::SkipEqualXY(x.into(), y.into())
[INFO] [stdout] 88 +                 Chip8Commands::SkipEqualXY(x.into(), y)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 -                 Chip8Commands::SkipEqualXY(x.into(), y.into())
[INFO] [stdout] 88 +                 Chip8Commands::SkipEqualXY(x.into(), <u8 as Into<_>>::into(y))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:93:47
[INFO] [stdout]    |
[INFO] [stdout] 93 |                 Chip8Commands::SkipNotEqualXY(x.into(), y.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] 93 -                 Chip8Commands::SkipNotEqualXY(x.into(), y.into())
[INFO] [stdout] 93 +                 Chip8Commands::SkipNotEqualXY(x, y.into())
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 -                 Chip8Commands::SkipNotEqualXY(x.into(), y.into())
[INFO] [stdout] 93 +                 Chip8Commands::SkipNotEqualXY(<u8 as Into<_>>::into(x), y.into())
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:93:57
[INFO] [stdout]    |
[INFO] [stdout] 93 |                 Chip8Commands::SkipNotEqualXY(x.into(), y.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] 93 -                 Chip8Commands::SkipNotEqualXY(x.into(), y.into())
[INFO] [stdout] 93 +                 Chip8Commands::SkipNotEqualXY(x.into(), y)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 -                 Chip8Commands::SkipNotEqualXY(x.into(), y.into())
[INFO] [stdout] 93 +                 Chip8Commands::SkipNotEqualXY(x.into(), <u8 as Into<_>>::into(y))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:99:37
[INFO] [stdout]    |
[INFO] [stdout] 99 |                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout]    |                                     ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 99 -                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout] 99 +                 Chip8Commands::Draw(x, y.into(), bytes)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 -                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout] 99 +                 Chip8Commands::Draw(<u8 as Into<_>>::into(x), y.into(), bytes)
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:99:47
[INFO] [stdout]    |
[INFO] [stdout] 99 |                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout]    |                                               ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 99 -                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout] 99 +                 Chip8Commands::Draw(x.into(), y, bytes)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 -                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout] 99 +                 Chip8Commands::Draw(x.into(), <u8 as Into<_>>::into(y), bytes)
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:42:50
[INFO] [stdout]    |
[INFO] [stdout] 42 |                 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])),
[INFO] [stdout]    |                                                  ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -                 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])),
[INFO] [stdout] 42 +                 4 => Box::new(SkipNotEqualX::new(x, command[1])),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -                 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])),
[INFO] [stdout] 42 +                 4 => Box::new(SkipNotEqualX::new(<u8 as Into<_>>::into(x), command[1])),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:43:48
[INFO] [stdout]    |
[INFO] [stdout] 43 |                 6 => Box::new(SetRegister::new(x.into(), command[1])),
[INFO] [stdout]    |                                                ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 43 -                 6 => Box::new(SetRegister::new(x.into(), command[1])),
[INFO] [stdout] 43 +                 6 => Box::new(SetRegister::new(x, command[1])),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 -                 6 => Box::new(SetRegister::new(x.into(), command[1])),
[INFO] [stdout] 43 +                 6 => Box::new(SetRegister::new(<u8 as Into<_>>::into(x), command[1])),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:44:55
[INFO] [stdout]    |
[INFO] [stdout] 44 |                 7 => Box::new(AddValueToRegister::new(x.into(), command[1])),
[INFO] [stdout]    |                                                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 44 -                 7 => Box::new(AddValueToRegister::new(x.into(), command[1])),
[INFO] [stdout] 44 +                 7 => Box::new(AddValueToRegister::new(x, command[1])),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 -                 7 => Box::new(AddValueToRegister::new(x.into(), command[1])),
[INFO] [stdout] 44 +                 7 => Box::new(AddValueToRegister::new(<u8 as Into<_>>::into(x), command[1])),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:53:43
[INFO] [stdout]    |
[INFO] [stdout] 53 |                 0x0 => Box::new(Load::new(x.into(), y.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] 53 -                 0x0 => Box::new(Load::new(x.into(), y.into())),
[INFO] [stdout] 53 +                 0x0 => Box::new(Load::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 -                 0x0 => Box::new(Load::new(x.into(), y.into())),
[INFO] [stdout] 53 +                 0x0 => Box::new(Load::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:53:53
[INFO] [stdout]    |
[INFO] [stdout] 53 |                 0x0 => Box::new(Load::new(x.into(), y.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] 53 -                 0x0 => Box::new(Load::new(x.into(), y.into())),
[INFO] [stdout] 53 +                 0x0 => Box::new(Load::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 -                 0x0 => Box::new(Load::new(x.into(), y.into())),
[INFO] [stdout] 53 +                 0x0 => Box::new(Load::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:54:41
[INFO] [stdout]    |
[INFO] [stdout] 54 |                 0x1 => Box::new(Or::new(x.into(), y.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] 54 -                 0x1 => Box::new(Or::new(x.into(), y.into())),
[INFO] [stdout] 54 +                 0x1 => Box::new(Or::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -                 0x1 => Box::new(Or::new(x.into(), y.into())),
[INFO] [stdout] 54 +                 0x1 => Box::new(Or::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:54:51
[INFO] [stdout]    |
[INFO] [stdout] 54 |                 0x1 => Box::new(Or::new(x.into(), y.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] 54 -                 0x1 => Box::new(Or::new(x.into(), y.into())),
[INFO] [stdout] 54 +                 0x1 => Box::new(Or::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -                 0x1 => Box::new(Or::new(x.into(), y.into())),
[INFO] [stdout] 54 +                 0x1 => Box::new(Or::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:55:42
[INFO] [stdout]    |
[INFO] [stdout] 55 |                 0x2 => Box::new(And::new(x.into(), y.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] 55 -                 0x2 => Box::new(And::new(x.into(), y.into())),
[INFO] [stdout] 55 +                 0x2 => Box::new(And::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                 0x2 => Box::new(And::new(x.into(), y.into())),
[INFO] [stdout] 55 +                 0x2 => Box::new(And::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:55:52
[INFO] [stdout]    |
[INFO] [stdout] 55 |                 0x2 => Box::new(And::new(x.into(), y.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] 55 -                 0x2 => Box::new(And::new(x.into(), y.into())),
[INFO] [stdout] 55 +                 0x2 => Box::new(And::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                 0x2 => Box::new(And::new(x.into(), y.into())),
[INFO] [stdout] 55 +                 0x2 => Box::new(And::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:56:42
[INFO] [stdout]    |
[INFO] [stdout] 56 |                 0x3 => Box::new(Xor::new(x.into(), y.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] 56 -                 0x3 => Box::new(Xor::new(x.into(), y.into())),
[INFO] [stdout] 56 +                 0x3 => Box::new(Xor::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -                 0x3 => Box::new(Xor::new(x.into(), y.into())),
[INFO] [stdout] 56 +                 0x3 => Box::new(Xor::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:56:52
[INFO] [stdout]    |
[INFO] [stdout] 56 |                 0x3 => Box::new(Xor::new(x.into(), y.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] 56 -                 0x3 => Box::new(Xor::new(x.into(), y.into())),
[INFO] [stdout] 56 +                 0x3 => Box::new(Xor::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -                 0x3 => Box::new(Xor::new(x.into(), y.into())),
[INFO] [stdout] 56 +                 0x3 => Box::new(Xor::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:57:42
[INFO] [stdout]    |
[INFO] [stdout] 57 |                 0x4 => Box::new(Add::new(x.into(), y.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] 57 -                 0x4 => Box::new(Add::new(x.into(), y.into())),
[INFO] [stdout] 57 +                 0x4 => Box::new(Add::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -                 0x4 => Box::new(Add::new(x.into(), y.into())),
[INFO] [stdout] 57 +                 0x4 => Box::new(Add::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:57:52
[INFO] [stdout]    |
[INFO] [stdout] 57 |                 0x4 => Box::new(Add::new(x.into(), y.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] 57 -                 0x4 => Box::new(Add::new(x.into(), y.into())),
[INFO] [stdout] 57 +                 0x4 => Box::new(Add::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -                 0x4 => Box::new(Add::new(x.into(), y.into())),
[INFO] [stdout] 57 +                 0x4 => Box::new(Add::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:58:42
[INFO] [stdout]    |
[INFO] [stdout] 58 |                 0x5 => Box::new(Sub::new(x.into(), y.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] 58 -                 0x5 => Box::new(Sub::new(x.into(), y.into())),
[INFO] [stdout] 58 +                 0x5 => Box::new(Sub::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -                 0x5 => Box::new(Sub::new(x.into(), y.into())),
[INFO] [stdout] 58 +                 0x5 => Box::new(Sub::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:58:52
[INFO] [stdout]    |
[INFO] [stdout] 58 |                 0x5 => Box::new(Sub::new(x.into(), y.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] 58 -                 0x5 => Box::new(Sub::new(x.into(), y.into())),
[INFO] [stdout] 58 +                 0x5 => Box::new(Sub::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -                 0x5 => Box::new(Sub::new(x.into(), y.into())),
[INFO] [stdout] 58 +                 0x5 => Box::new(Sub::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:59:49
[INFO] [stdout]    |
[INFO] [stdout] 59 |                 0x6 => Box::new(ShiftRight::new(x.into(), y.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] 59 -                 0x6 => Box::new(ShiftRight::new(x.into(), y.into())),
[INFO] [stdout] 59 +                 0x6 => Box::new(ShiftRight::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -                 0x6 => Box::new(ShiftRight::new(x.into(), y.into())),
[INFO] [stdout] 59 +                 0x6 => Box::new(ShiftRight::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:59:59
[INFO] [stdout]    |
[INFO] [stdout] 59 |                 0x6 => Box::new(ShiftRight::new(x.into(), y.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] 59 -                 0x6 => Box::new(ShiftRight::new(x.into(), y.into())),
[INFO] [stdout] 59 +                 0x6 => Box::new(ShiftRight::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -                 0x6 => Box::new(ShiftRight::new(x.into(), y.into())),
[INFO] [stdout] 59 +                 0x6 => Box::new(ShiftRight::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:60:43
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 0x7 => Box::new(SubN::new(x.into(), y.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] 60 -                 0x7 => Box::new(SubN::new(x.into(), y.into())),
[INFO] [stdout] 60 +                 0x7 => Box::new(SubN::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                 0x7 => Box::new(SubN::new(x.into(), y.into())),
[INFO] [stdout] 60 +                 0x7 => Box::new(SubN::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:60:53
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 0x7 => Box::new(SubN::new(x.into(), y.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] 60 -                 0x7 => Box::new(SubN::new(x.into(), y.into())),
[INFO] [stdout] 60 +                 0x7 => Box::new(SubN::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                 0x7 => Box::new(SubN::new(x.into(), y.into())),
[INFO] [stdout] 60 +                 0x7 => Box::new(SubN::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:61:48
[INFO] [stdout]    |
[INFO] [stdout] 61 |                 0xE => Box::new(ShiftLeft::new(x.into(), y.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] 61 -                 0xE => Box::new(ShiftLeft::new(x.into(), y.into())),
[INFO] [stdout] 61 +                 0xE => Box::new(ShiftLeft::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                 0xE => Box::new(ShiftLeft::new(x.into(), y.into())),
[INFO] [stdout] 61 +                 0xE => Box::new(ShiftLeft::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:61:58
[INFO] [stdout]    |
[INFO] [stdout] 61 |                 0xE => Box::new(ShiftLeft::new(x.into(), y.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] 61 -                 0xE => Box::new(ShiftLeft::new(x.into(), y.into())),
[INFO] [stdout] 61 +                 0xE => Box::new(ShiftLeft::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                 0xE => Box::new(ShiftLeft::new(x.into(), y.into())),
[INFO] [stdout] 61 +                 0xE => Box::new(ShiftLeft::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:68:60
[INFO] [stdout]    |
[INFO] [stdout] 68 |                 0x07 => Box::new(SetRegisterFromDelay::new(x.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] 68 -                 0x07 => Box::new(SetRegisterFromDelay::new(x.into())),
[INFO] [stdout] 68 +                 0x07 => Box::new(SetRegisterFromDelay::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 0x07 => Box::new(SetRegisterFromDelay::new(x.into())),
[INFO] [stdout] 68 +                 0x07 => Box::new(SetRegisterFromDelay::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:69:53
[INFO] [stdout]    |
[INFO] [stdout] 69 |                 0x15 => Box::new(SetDelayTimer::new(x.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] 69 -                 0x15 => Box::new(SetDelayTimer::new(x.into())),
[INFO] [stdout] 69 +                 0x15 => Box::new(SetDelayTimer::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -                 0x15 => Box::new(SetDelayTimer::new(x.into())),
[INFO] [stdout] 69 +                 0x15 => Box::new(SetDelayTimer::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:70:50
[INFO] [stdout]    |
[INFO] [stdout] 70 |                 0x1E => Box::new(AddToIndex::new(x.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] 70 -                 0x1E => Box::new(AddToIndex::new(x.into())),
[INFO] [stdout] 70 +                 0x1E => Box::new(AddToIndex::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 -                 0x1E => Box::new(AddToIndex::new(x.into())),
[INFO] [stdout] 70 +                 0x1E => Box::new(AddToIndex::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:71:58
[INFO] [stdout]    |
[INFO] [stdout] 71 |                 0x33 => Box::new(BinaryCodedDecimal::new(x.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] 71 -                 0x33 => Box::new(BinaryCodedDecimal::new(x.into())),
[INFO] [stdout] 71 +                 0x33 => Box::new(BinaryCodedDecimal::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 -                 0x33 => Box::new(BinaryCodedDecimal::new(x.into())),
[INFO] [stdout] 71 +                 0x33 => Box::new(BinaryCodedDecimal::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:72:54
[INFO] [stdout]    |
[INFO] [stdout] 72 |                 0x55 => Box::new(StoreRegisters::new(x.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] 72 -                 0x55 => Box::new(StoreRegisters::new(x.into())),
[INFO] [stdout] 72 +                 0x55 => Box::new(StoreRegisters::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 -                 0x55 => Box::new(StoreRegisters::new(x.into())),
[INFO] [stdout] 72 +                 0x55 => Box::new(StoreRegisters::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:73:57
[INFO] [stdout]    |
[INFO] [stdout] 73 |                 0x65 => Box::new(ReadIntoRegisters::new(x.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] 73 -                 0x65 => Box::new(ReadIntoRegisters::new(x.into())),
[INFO] [stdout] 73 +                 0x65 => Box::new(ReadIntoRegisters::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 73 -                 0x65 => Box::new(ReadIntoRegisters::new(x.into())),
[INFO] [stdout] 73 +                 0x65 => Box::new(ReadIntoRegisters::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:89:39
[INFO] [stdout]    |
[INFO] [stdout] 89 |             Box::new(SkipEqualXY::new(x.into(), y.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] 89 -             Box::new(SkipEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 89 +             Box::new(SkipEqualXY::new(x, y.into()))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 -             Box::new(SkipEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 89 +             Box::new(SkipEqualXY::new(<u8 as Into<_>>::into(x), y.into()))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:89:49
[INFO] [stdout]    |
[INFO] [stdout] 89 |             Box::new(SkipEqualXY::new(x.into(), y.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] 89 -             Box::new(SkipEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 89 +             Box::new(SkipEqualXY::new(x.into(), y))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 -             Box::new(SkipEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 89 +             Box::new(SkipEqualXY::new(x.into(), <u8 as Into<_>>::into(y)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:94:42
[INFO] [stdout]    |
[INFO] [stdout] 94 |             Box::new(SkipNotEqualXY::new(x.into(), y.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] 94 -             Box::new(SkipNotEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 94 +             Box::new(SkipNotEqualXY::new(x, y.into()))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -             Box::new(SkipNotEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 94 +             Box::new(SkipNotEqualXY::new(<u8 as Into<_>>::into(x), y.into()))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:94:52
[INFO] [stdout]    |
[INFO] [stdout] 94 |             Box::new(SkipNotEqualXY::new(x.into(), y.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] 94 -             Box::new(SkipNotEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 94 +             Box::new(SkipNotEqualXY::new(x.into(), y))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -             Box::new(SkipNotEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 94 +             Box::new(SkipNotEqualXY::new(x.into(), <u8 as Into<_>>::into(y)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `chip8` (bin "chip8") due to 65 previous errors; 80 warnings emitted
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/commands/command_parser.rs:100:32
[INFO] [stdout]     |
[INFO] [stdout] 100 |             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout]     |                                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 100 -             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout] 100 +             Box::new(Draw::new(x, y.into(), bytes))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 -             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout] 100 +             Box::new(Draw::new(<u8 as Into<_>>::into(x), y.into(), bytes))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/commands/command_parser.rs:100:42
[INFO] [stdout]     |
[INFO] [stdout] 100 |             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout]     |                                          ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 100 -             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout] 100 +             Box::new(Draw::new(x.into(), y, bytes))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 -             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout] 100 +             Box::new(Draw::new(x.into(), <u8 as Into<_>>::into(y), bytes))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: field `sound_timer` is never read
[INFO] [stdout]   --> src/main.rs:25:5
[INFO] [stdout]    |
[INFO] [stdout] 18 | struct Chip8 {
[INFO] [stdout]    |        ----- field in this struct
[INFO] [stdout] ...
[INFO] [stdout] 25 |     sound_timer: u8,
[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: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:42:52
[INFO] [stdout]    |
[INFO] [stdout] 42 |                     3 => Chip8Commands::SkipEqualX(x.into(), command[1]),
[INFO] [stdout]    |                                                    ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -                     3 => Chip8Commands::SkipEqualX(x.into(), command[1]),
[INFO] [stdout] 42 +                     3 => Chip8Commands::SkipEqualX(x, command[1]),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -                     3 => Chip8Commands::SkipEqualX(x.into(), command[1]),
[INFO] [stdout] 42 +                     3 => Chip8Commands::SkipEqualX(<u8 as Into<_>>::into(x), command[1]),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:43:55
[INFO] [stdout]    |
[INFO] [stdout] 43 |                     4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]),
[INFO] [stdout]    |                                                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 43 -                     4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]),
[INFO] [stdout] 43 +                     4 => Chip8Commands::SkipNotEqualX(x, command[1]),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 -                     4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]),
[INFO] [stdout] 43 +                     4 => Chip8Commands::SkipNotEqualX(<u8 as Into<_>>::into(x), command[1]),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:44:53
[INFO] [stdout]    |
[INFO] [stdout] 44 |                     6 => Chip8Commands::SetRegister(x.into(), command[1]),
[INFO] [stdout]    |                                                     ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 44 -                     6 => Chip8Commands::SetRegister(x.into(), command[1]),
[INFO] [stdout] 44 +                     6 => Chip8Commands::SetRegister(x, command[1]),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 -                     6 => Chip8Commands::SetRegister(x.into(), command[1]),
[INFO] [stdout] 44 +                     6 => Chip8Commands::SetRegister(<u8 as Into<_>>::into(x), command[1]),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:45:60
[INFO] [stdout]    |
[INFO] [stdout] 45 |                     7 => Chip8Commands::AddValueToRegister(x.into(), command[1]),
[INFO] [stdout]    |                                                            ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 45 -                     7 => Chip8Commands::AddValueToRegister(x.into(), command[1]),
[INFO] [stdout] 45 +                     7 => Chip8Commands::AddValueToRegister(x, command[1]),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 45 -                     7 => Chip8Commands::AddValueToRegister(x.into(), command[1]),
[INFO] [stdout] 45 +                     7 => Chip8Commands::AddValueToRegister(<u8 as Into<_>>::into(x), command[1]),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:54:48
[INFO] [stdout]    |
[INFO] [stdout] 54 |                     0x0 => Chip8Commands::Load(x.into(), y.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] 54 -                     0x0 => Chip8Commands::Load(x.into(), y.into()),
[INFO] [stdout] 54 +                     0x0 => Chip8Commands::Load(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -                     0x0 => Chip8Commands::Load(x.into(), y.into()),
[INFO] [stdout] 54 +                     0x0 => Chip8Commands::Load(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:54:58
[INFO] [stdout]    |
[INFO] [stdout] 54 |                     0x0 => Chip8Commands::Load(x.into(), y.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] 54 -                     0x0 => Chip8Commands::Load(x.into(), y.into()),
[INFO] [stdout] 54 +                     0x0 => Chip8Commands::Load(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -                     0x0 => Chip8Commands::Load(x.into(), y.into()),
[INFO] [stdout] 54 +                     0x0 => Chip8Commands::Load(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:55:46
[INFO] [stdout]    |
[INFO] [stdout] 55 |                     0x1 => Chip8Commands::OR(x.into(), y.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] 55 -                     0x1 => Chip8Commands::OR(x.into(), y.into()),
[INFO] [stdout] 55 +                     0x1 => Chip8Commands::OR(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                     0x1 => Chip8Commands::OR(x.into(), y.into()),
[INFO] [stdout] 55 +                     0x1 => Chip8Commands::OR(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:55:56
[INFO] [stdout]    |
[INFO] [stdout] 55 |                     0x1 => Chip8Commands::OR(x.into(), y.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] 55 -                     0x1 => Chip8Commands::OR(x.into(), y.into()),
[INFO] [stdout] 55 +                     0x1 => Chip8Commands::OR(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                     0x1 => Chip8Commands::OR(x.into(), y.into()),
[INFO] [stdout] 55 +                     0x1 => Chip8Commands::OR(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:56:47
[INFO] [stdout]    |
[INFO] [stdout] 56 |                     0x2 => Chip8Commands::AND(x.into(), y.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] 56 -                     0x2 => Chip8Commands::AND(x.into(), y.into()),
[INFO] [stdout] 56 +                     0x2 => Chip8Commands::AND(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -                     0x2 => Chip8Commands::AND(x.into(), y.into()),
[INFO] [stdout] 56 +                     0x2 => Chip8Commands::AND(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:56:57
[INFO] [stdout]    |
[INFO] [stdout] 56 |                     0x2 => Chip8Commands::AND(x.into(), y.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] 56 -                     0x2 => Chip8Commands::AND(x.into(), y.into()),
[INFO] [stdout] 56 +                     0x2 => Chip8Commands::AND(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -                     0x2 => Chip8Commands::AND(x.into(), y.into()),
[INFO] [stdout] 56 +                     0x2 => Chip8Commands::AND(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:57:47
[INFO] [stdout]    |
[INFO] [stdout] 57 |                     0x3 => Chip8Commands::XOR(x.into(), y.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] 57 -                     0x3 => Chip8Commands::XOR(x.into(), y.into()),
[INFO] [stdout] 57 +                     0x3 => Chip8Commands::XOR(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -                     0x3 => Chip8Commands::XOR(x.into(), y.into()),
[INFO] [stdout] 57 +                     0x3 => Chip8Commands::XOR(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:57:57
[INFO] [stdout]    |
[INFO] [stdout] 57 |                     0x3 => Chip8Commands::XOR(x.into(), y.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] 57 -                     0x3 => Chip8Commands::XOR(x.into(), y.into()),
[INFO] [stdout] 57 +                     0x3 => Chip8Commands::XOR(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -                     0x3 => Chip8Commands::XOR(x.into(), y.into()),
[INFO] [stdout] 57 +                     0x3 => Chip8Commands::XOR(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:58:47
[INFO] [stdout]    |
[INFO] [stdout] 58 |                     0x4 => Chip8Commands::ADD(x.into(), y.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] 58 -                     0x4 => Chip8Commands::ADD(x.into(), y.into()),
[INFO] [stdout] 58 +                     0x4 => Chip8Commands::ADD(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -                     0x4 => Chip8Commands::ADD(x.into(), y.into()),
[INFO] [stdout] 58 +                     0x4 => Chip8Commands::ADD(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:58:57
[INFO] [stdout]    |
[INFO] [stdout] 58 |                     0x4 => Chip8Commands::ADD(x.into(), y.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] 58 -                     0x4 => Chip8Commands::ADD(x.into(), y.into()),
[INFO] [stdout] 58 +                     0x4 => Chip8Commands::ADD(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -                     0x4 => Chip8Commands::ADD(x.into(), y.into()),
[INFO] [stdout] 58 +                     0x4 => Chip8Commands::ADD(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:59:47
[INFO] [stdout]    |
[INFO] [stdout] 59 |                     0x5 => Chip8Commands::SUB(x.into(), y.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] 59 -                     0x5 => Chip8Commands::SUB(x.into(), y.into()),
[INFO] [stdout] 59 +                     0x5 => Chip8Commands::SUB(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -                     0x5 => Chip8Commands::SUB(x.into(), y.into()),
[INFO] [stdout] 59 +                     0x5 => Chip8Commands::SUB(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:59:57
[INFO] [stdout]    |
[INFO] [stdout] 59 |                     0x5 => Chip8Commands::SUB(x.into(), y.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] 59 -                     0x5 => Chip8Commands::SUB(x.into(), y.into()),
[INFO] [stdout] 59 +                     0x5 => Chip8Commands::SUB(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -                     0x5 => Chip8Commands::SUB(x.into(), y.into()),
[INFO] [stdout] 59 +                     0x5 => Chip8Commands::SUB(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:60:54
[INFO] [stdout]    |
[INFO] [stdout] 60 |                     0x6 => Chip8Commands::ShiftRight(x.into(), y.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] 60 -                     0x6 => Chip8Commands::ShiftRight(x.into(), y.into()),
[INFO] [stdout] 60 +                     0x6 => Chip8Commands::ShiftRight(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                     0x6 => Chip8Commands::ShiftRight(x.into(), y.into()),
[INFO] [stdout] 60 +                     0x6 => Chip8Commands::ShiftRight(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:60:64
[INFO] [stdout]    |
[INFO] [stdout] 60 |                     0x6 => Chip8Commands::ShiftRight(x.into(), y.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] 60 -                     0x6 => Chip8Commands::ShiftRight(x.into(), y.into()),
[INFO] [stdout] 60 +                     0x6 => Chip8Commands::ShiftRight(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                     0x6 => Chip8Commands::ShiftRight(x.into(), y.into()),
[INFO] [stdout] 60 +                     0x6 => Chip8Commands::ShiftRight(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:61:48
[INFO] [stdout]    |
[INFO] [stdout] 61 |                     0x7 => Chip8Commands::SUBN(x.into(), y.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] 61 -                     0x7 => Chip8Commands::SUBN(x.into(), y.into()),
[INFO] [stdout] 61 +                     0x7 => Chip8Commands::SUBN(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                     0x7 => Chip8Commands::SUBN(x.into(), y.into()),
[INFO] [stdout] 61 +                     0x7 => Chip8Commands::SUBN(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:61:58
[INFO] [stdout]    |
[INFO] [stdout] 61 |                     0x7 => Chip8Commands::SUBN(x.into(), y.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] 61 -                     0x7 => Chip8Commands::SUBN(x.into(), y.into()),
[INFO] [stdout] 61 +                     0x7 => Chip8Commands::SUBN(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                     0x7 => Chip8Commands::SUBN(x.into(), y.into()),
[INFO] [stdout] 61 +                     0x7 => Chip8Commands::SUBN(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:62:53
[INFO] [stdout]    |
[INFO] [stdout] 62 |                     0xE => Chip8Commands::ShiftLeft(x.into(), y.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] 62 -                     0xE => Chip8Commands::ShiftLeft(x.into(), y.into()),
[INFO] [stdout] 62 +                     0xE => Chip8Commands::ShiftLeft(x, y.into()),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -                     0xE => Chip8Commands::ShiftLeft(x.into(), y.into()),
[INFO] [stdout] 62 +                     0xE => Chip8Commands::ShiftLeft(<u8 as Into<_>>::into(x), y.into()),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:62:63
[INFO] [stdout]    |
[INFO] [stdout] 62 |                     0xE => Chip8Commands::ShiftLeft(x.into(), y.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] 62 -                     0xE => Chip8Commands::ShiftLeft(x.into(), y.into()),
[INFO] [stdout] 62 +                     0xE => Chip8Commands::ShiftLeft(x.into(), y),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -                     0xE => Chip8Commands::ShiftLeft(x.into(), y.into()),
[INFO] [stdout] 62 +                     0xE => Chip8Commands::ShiftLeft(x.into(), <u8 as Into<_>>::into(y)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:69:55
[INFO] [stdout]    |
[INFO] [stdout] 69 |                     0x1E => Chip8Commands::AddToIndex(x.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] 69 -                     0x1E => Chip8Commands::AddToIndex(x.into()),
[INFO] [stdout] 69 +                     0x1E => Chip8Commands::AddToIndex(x),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -                     0x1E => Chip8Commands::AddToIndex(x.into()),
[INFO] [stdout] 69 +                     0x1E => Chip8Commands::AddToIndex(<u8 as Into<_>>::into(x)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:70:63
[INFO] [stdout]    |
[INFO] [stdout] 70 |                     0x33 => Chip8Commands::BinaryCodedDecimal(x.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] 70 -                     0x33 => Chip8Commands::BinaryCodedDecimal(x.into()),
[INFO] [stdout] 70 +                     0x33 => Chip8Commands::BinaryCodedDecimal(x),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 -                     0x33 => Chip8Commands::BinaryCodedDecimal(x.into()),
[INFO] [stdout] 70 +                     0x33 => Chip8Commands::BinaryCodedDecimal(<u8 as Into<_>>::into(x)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:71:59
[INFO] [stdout]    |
[INFO] [stdout] 71 |                     0x55 => Chip8Commands::StoreRegisters(x.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] 71 -                     0x55 => Chip8Commands::StoreRegisters(x.into()),
[INFO] [stdout] 71 +                     0x55 => Chip8Commands::StoreRegisters(x),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 -                     0x55 => Chip8Commands::StoreRegisters(x.into()),
[INFO] [stdout] 71 +                     0x55 => Chip8Commands::StoreRegisters(<u8 as Into<_>>::into(x)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:72:62
[INFO] [stdout]    |
[INFO] [stdout] 72 |                     0x65 => Chip8Commands::ReadIntoRegisters(x.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] 72 -                     0x65 => Chip8Commands::ReadIntoRegisters(x.into()),
[INFO] [stdout] 72 +                     0x65 => Chip8Commands::ReadIntoRegisters(x),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 -                     0x65 => Chip8Commands::ReadIntoRegisters(x.into()),
[INFO] [stdout] 72 +                     0x65 => Chip8Commands::ReadIntoRegisters(<u8 as Into<_>>::into(x)),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:88:44
[INFO] [stdout]    |
[INFO] [stdout] 88 |                 Chip8Commands::SkipEqualXY(x.into(), y.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] 88 -                 Chip8Commands::SkipEqualXY(x.into(), y.into())
[INFO] [stdout] 88 +                 Chip8Commands::SkipEqualXY(x, y.into())
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 -                 Chip8Commands::SkipEqualXY(x.into(), y.into())
[INFO] [stdout] 88 +                 Chip8Commands::SkipEqualXY(<u8 as Into<_>>::into(x), y.into())
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:88:54
[INFO] [stdout]    |
[INFO] [stdout] 88 |                 Chip8Commands::SkipEqualXY(x.into(), y.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] 88 -                 Chip8Commands::SkipEqualXY(x.into(), y.into())
[INFO] [stdout] 88 +                 Chip8Commands::SkipEqualXY(x.into(), y)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 -                 Chip8Commands::SkipEqualXY(x.into(), y.into())
[INFO] [stdout] 88 +                 Chip8Commands::SkipEqualXY(x.into(), <u8 as Into<_>>::into(y))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:93:47
[INFO] [stdout]    |
[INFO] [stdout] 93 |                 Chip8Commands::SkipNotEqualXY(x.into(), y.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] 93 -                 Chip8Commands::SkipNotEqualXY(x.into(), y.into())
[INFO] [stdout] 93 +                 Chip8Commands::SkipNotEqualXY(x, y.into())
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 -                 Chip8Commands::SkipNotEqualXY(x.into(), y.into())
[INFO] [stdout] 93 +                 Chip8Commands::SkipNotEqualXY(<u8 as Into<_>>::into(x), y.into())
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:93:57
[INFO] [stdout]    |
[INFO] [stdout] 93 |                 Chip8Commands::SkipNotEqualXY(x.into(), y.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] 93 -                 Chip8Commands::SkipNotEqualXY(x.into(), y.into())
[INFO] [stdout] 93 +                 Chip8Commands::SkipNotEqualXY(x.into(), y)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 -                 Chip8Commands::SkipNotEqualXY(x.into(), y.into())
[INFO] [stdout] 93 +                 Chip8Commands::SkipNotEqualXY(x.into(), <u8 as Into<_>>::into(y))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:99:37
[INFO] [stdout]    |
[INFO] [stdout] 99 |                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout]    |                                     ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 99 -                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout] 99 +                 Chip8Commands::Draw(x, y.into(), bytes)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 -                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout] 99 +                 Chip8Commands::Draw(<u8 as Into<_>>::into(x), y.into(), bytes)
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/chip8_commands.rs:99:47
[INFO] [stdout]    |
[INFO] [stdout] 99 |                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout]    |                                               ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 99 -                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout] 99 +                 Chip8Commands::Draw(x.into(), y, bytes)
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 -                 Chip8Commands::Draw(x.into(), y.into(), bytes)
[INFO] [stdout] 99 +                 Chip8Commands::Draw(x.into(), <u8 as Into<_>>::into(y), bytes)
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:42:50
[INFO] [stdout]    |
[INFO] [stdout] 42 |                 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])),
[INFO] [stdout]    |                                                  ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 42 -                 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])),
[INFO] [stdout] 42 +                 4 => Box::new(SkipNotEqualX::new(x, command[1])),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 -                 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])),
[INFO] [stdout] 42 +                 4 => Box::new(SkipNotEqualX::new(<u8 as Into<_>>::into(x), command[1])),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:43:48
[INFO] [stdout]    |
[INFO] [stdout] 43 |                 6 => Box::new(SetRegister::new(x.into(), command[1])),
[INFO] [stdout]    |                                                ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 43 -                 6 => Box::new(SetRegister::new(x.into(), command[1])),
[INFO] [stdout] 43 +                 6 => Box::new(SetRegister::new(x, command[1])),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 -                 6 => Box::new(SetRegister::new(x.into(), command[1])),
[INFO] [stdout] 43 +                 6 => Box::new(SetRegister::new(<u8 as Into<_>>::into(x), command[1])),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:44:55
[INFO] [stdout]    |
[INFO] [stdout] 44 |                 7 => Box::new(AddValueToRegister::new(x.into(), command[1])),
[INFO] [stdout]    |                                                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 44 -                 7 => Box::new(AddValueToRegister::new(x.into(), command[1])),
[INFO] [stdout] 44 +                 7 => Box::new(AddValueToRegister::new(x, command[1])),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 -                 7 => Box::new(AddValueToRegister::new(x.into(), command[1])),
[INFO] [stdout] 44 +                 7 => Box::new(AddValueToRegister::new(<u8 as Into<_>>::into(x), command[1])),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:53:43
[INFO] [stdout]    |
[INFO] [stdout] 53 |                 0x0 => Box::new(Load::new(x.into(), y.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] 53 -                 0x0 => Box::new(Load::new(x.into(), y.into())),
[INFO] [stdout] 53 +                 0x0 => Box::new(Load::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 -                 0x0 => Box::new(Load::new(x.into(), y.into())),
[INFO] [stdout] 53 +                 0x0 => Box::new(Load::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:53:53
[INFO] [stdout]    |
[INFO] [stdout] 53 |                 0x0 => Box::new(Load::new(x.into(), y.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] 53 -                 0x0 => Box::new(Load::new(x.into(), y.into())),
[INFO] [stdout] 53 +                 0x0 => Box::new(Load::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 -                 0x0 => Box::new(Load::new(x.into(), y.into())),
[INFO] [stdout] 53 +                 0x0 => Box::new(Load::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:54:41
[INFO] [stdout]    |
[INFO] [stdout] 54 |                 0x1 => Box::new(Or::new(x.into(), y.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] 54 -                 0x1 => Box::new(Or::new(x.into(), y.into())),
[INFO] [stdout] 54 +                 0x1 => Box::new(Or::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -                 0x1 => Box::new(Or::new(x.into(), y.into())),
[INFO] [stdout] 54 +                 0x1 => Box::new(Or::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:54:51
[INFO] [stdout]    |
[INFO] [stdout] 54 |                 0x1 => Box::new(Or::new(x.into(), y.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] 54 -                 0x1 => Box::new(Or::new(x.into(), y.into())),
[INFO] [stdout] 54 +                 0x1 => Box::new(Or::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 -                 0x1 => Box::new(Or::new(x.into(), y.into())),
[INFO] [stdout] 54 +                 0x1 => Box::new(Or::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:55:42
[INFO] [stdout]    |
[INFO] [stdout] 55 |                 0x2 => Box::new(And::new(x.into(), y.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] 55 -                 0x2 => Box::new(And::new(x.into(), y.into())),
[INFO] [stdout] 55 +                 0x2 => Box::new(And::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                 0x2 => Box::new(And::new(x.into(), y.into())),
[INFO] [stdout] 55 +                 0x2 => Box::new(And::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:55:52
[INFO] [stdout]    |
[INFO] [stdout] 55 |                 0x2 => Box::new(And::new(x.into(), y.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] 55 -                 0x2 => Box::new(And::new(x.into(), y.into())),
[INFO] [stdout] 55 +                 0x2 => Box::new(And::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -                 0x2 => Box::new(And::new(x.into(), y.into())),
[INFO] [stdout] 55 +                 0x2 => Box::new(And::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:56:42
[INFO] [stdout]    |
[INFO] [stdout] 56 |                 0x3 => Box::new(Xor::new(x.into(), y.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] 56 -                 0x3 => Box::new(Xor::new(x.into(), y.into())),
[INFO] [stdout] 56 +                 0x3 => Box::new(Xor::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -                 0x3 => Box::new(Xor::new(x.into(), y.into())),
[INFO] [stdout] 56 +                 0x3 => Box::new(Xor::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:56:52
[INFO] [stdout]    |
[INFO] [stdout] 56 |                 0x3 => Box::new(Xor::new(x.into(), y.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] 56 -                 0x3 => Box::new(Xor::new(x.into(), y.into())),
[INFO] [stdout] 56 +                 0x3 => Box::new(Xor::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 -                 0x3 => Box::new(Xor::new(x.into(), y.into())),
[INFO] [stdout] 56 +                 0x3 => Box::new(Xor::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:57:42
[INFO] [stdout]    |
[INFO] [stdout] 57 |                 0x4 => Box::new(Add::new(x.into(), y.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] 57 -                 0x4 => Box::new(Add::new(x.into(), y.into())),
[INFO] [stdout] 57 +                 0x4 => Box::new(Add::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -                 0x4 => Box::new(Add::new(x.into(), y.into())),
[INFO] [stdout] 57 +                 0x4 => Box::new(Add::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:57:52
[INFO] [stdout]    |
[INFO] [stdout] 57 |                 0x4 => Box::new(Add::new(x.into(), y.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] 57 -                 0x4 => Box::new(Add::new(x.into(), y.into())),
[INFO] [stdout] 57 +                 0x4 => Box::new(Add::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -                 0x4 => Box::new(Add::new(x.into(), y.into())),
[INFO] [stdout] 57 +                 0x4 => Box::new(Add::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:58:42
[INFO] [stdout]    |
[INFO] [stdout] 58 |                 0x5 => Box::new(Sub::new(x.into(), y.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] 58 -                 0x5 => Box::new(Sub::new(x.into(), y.into())),
[INFO] [stdout] 58 +                 0x5 => Box::new(Sub::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -                 0x5 => Box::new(Sub::new(x.into(), y.into())),
[INFO] [stdout] 58 +                 0x5 => Box::new(Sub::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:58:52
[INFO] [stdout]    |
[INFO] [stdout] 58 |                 0x5 => Box::new(Sub::new(x.into(), y.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] 58 -                 0x5 => Box::new(Sub::new(x.into(), y.into())),
[INFO] [stdout] 58 +                 0x5 => Box::new(Sub::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 -                 0x5 => Box::new(Sub::new(x.into(), y.into())),
[INFO] [stdout] 58 +                 0x5 => Box::new(Sub::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:59:49
[INFO] [stdout]    |
[INFO] [stdout] 59 |                 0x6 => Box::new(ShiftRight::new(x.into(), y.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] 59 -                 0x6 => Box::new(ShiftRight::new(x.into(), y.into())),
[INFO] [stdout] 59 +                 0x6 => Box::new(ShiftRight::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -                 0x6 => Box::new(ShiftRight::new(x.into(), y.into())),
[INFO] [stdout] 59 +                 0x6 => Box::new(ShiftRight::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:59:59
[INFO] [stdout]    |
[INFO] [stdout] 59 |                 0x6 => Box::new(ShiftRight::new(x.into(), y.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] 59 -                 0x6 => Box::new(ShiftRight::new(x.into(), y.into())),
[INFO] [stdout] 59 +                 0x6 => Box::new(ShiftRight::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -                 0x6 => Box::new(ShiftRight::new(x.into(), y.into())),
[INFO] [stdout] 59 +                 0x6 => Box::new(ShiftRight::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:60:43
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 0x7 => Box::new(SubN::new(x.into(), y.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] 60 -                 0x7 => Box::new(SubN::new(x.into(), y.into())),
[INFO] [stdout] 60 +                 0x7 => Box::new(SubN::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                 0x7 => Box::new(SubN::new(x.into(), y.into())),
[INFO] [stdout] 60 +                 0x7 => Box::new(SubN::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:60:53
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 0x7 => Box::new(SubN::new(x.into(), y.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] 60 -                 0x7 => Box::new(SubN::new(x.into(), y.into())),
[INFO] [stdout] 60 +                 0x7 => Box::new(SubN::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                 0x7 => Box::new(SubN::new(x.into(), y.into())),
[INFO] [stdout] 60 +                 0x7 => Box::new(SubN::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:61:48
[INFO] [stdout]    |
[INFO] [stdout] 61 |                 0xE => Box::new(ShiftLeft::new(x.into(), y.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] 61 -                 0xE => Box::new(ShiftLeft::new(x.into(), y.into())),
[INFO] [stdout] 61 +                 0xE => Box::new(ShiftLeft::new(x, y.into())),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                 0xE => Box::new(ShiftLeft::new(x.into(), y.into())),
[INFO] [stdout] 61 +                 0xE => Box::new(ShiftLeft::new(<u8 as Into<_>>::into(x), y.into())),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:61:58
[INFO] [stdout]    |
[INFO] [stdout] 61 |                 0xE => Box::new(ShiftLeft::new(x.into(), y.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] 61 -                 0xE => Box::new(ShiftLeft::new(x.into(), y.into())),
[INFO] [stdout] 61 +                 0xE => Box::new(ShiftLeft::new(x.into(), y)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                 0xE => Box::new(ShiftLeft::new(x.into(), y.into())),
[INFO] [stdout] 61 +                 0xE => Box::new(ShiftLeft::new(x.into(), <u8 as Into<_>>::into(y))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:68:60
[INFO] [stdout]    |
[INFO] [stdout] 68 |                 0x07 => Box::new(SetRegisterFromDelay::new(x.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] 68 -                 0x07 => Box::new(SetRegisterFromDelay::new(x.into())),
[INFO] [stdout] 68 +                 0x07 => Box::new(SetRegisterFromDelay::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 0x07 => Box::new(SetRegisterFromDelay::new(x.into())),
[INFO] [stdout] 68 +                 0x07 => Box::new(SetRegisterFromDelay::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:69:53
[INFO] [stdout]    |
[INFO] [stdout] 69 |                 0x15 => Box::new(SetDelayTimer::new(x.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] 69 -                 0x15 => Box::new(SetDelayTimer::new(x.into())),
[INFO] [stdout] 69 +                 0x15 => Box::new(SetDelayTimer::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -                 0x15 => Box::new(SetDelayTimer::new(x.into())),
[INFO] [stdout] 69 +                 0x15 => Box::new(SetDelayTimer::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:70:50
[INFO] [stdout]    |
[INFO] [stdout] 70 |                 0x1E => Box::new(AddToIndex::new(x.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] 70 -                 0x1E => Box::new(AddToIndex::new(x.into())),
[INFO] [stdout] 70 +                 0x1E => Box::new(AddToIndex::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 -                 0x1E => Box::new(AddToIndex::new(x.into())),
[INFO] [stdout] 70 +                 0x1E => Box::new(AddToIndex::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:71:58
[INFO] [stdout]    |
[INFO] [stdout] 71 |                 0x33 => Box::new(BinaryCodedDecimal::new(x.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] 71 -                 0x33 => Box::new(BinaryCodedDecimal::new(x.into())),
[INFO] [stdout] 71 +                 0x33 => Box::new(BinaryCodedDecimal::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 -                 0x33 => Box::new(BinaryCodedDecimal::new(x.into())),
[INFO] [stdout] 71 +                 0x33 => Box::new(BinaryCodedDecimal::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:72:54
[INFO] [stdout]    |
[INFO] [stdout] 72 |                 0x55 => Box::new(StoreRegisters::new(x.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] 72 -                 0x55 => Box::new(StoreRegisters::new(x.into())),
[INFO] [stdout] 72 +                 0x55 => Box::new(StoreRegisters::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 -                 0x55 => Box::new(StoreRegisters::new(x.into())),
[INFO] [stdout] 72 +                 0x55 => Box::new(StoreRegisters::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:73:57
[INFO] [stdout]    |
[INFO] [stdout] 73 |                 0x65 => Box::new(ReadIntoRegisters::new(x.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] 73 -                 0x65 => Box::new(ReadIntoRegisters::new(x.into())),
[INFO] [stdout] 73 +                 0x65 => Box::new(ReadIntoRegisters::new(x)),
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 73 -                 0x65 => Box::new(ReadIntoRegisters::new(x.into())),
[INFO] [stdout] 73 +                 0x65 => Box::new(ReadIntoRegisters::new(<u8 as Into<_>>::into(x))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:89:39
[INFO] [stdout]    |
[INFO] [stdout] 89 |             Box::new(SkipEqualXY::new(x.into(), y.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] 89 -             Box::new(SkipEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 89 +             Box::new(SkipEqualXY::new(x, y.into()))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 -             Box::new(SkipEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 89 +             Box::new(SkipEqualXY::new(<u8 as Into<_>>::into(x), y.into()))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:89:49
[INFO] [stdout]    |
[INFO] [stdout] 89 |             Box::new(SkipEqualXY::new(x.into(), y.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] 89 -             Box::new(SkipEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 89 +             Box::new(SkipEqualXY::new(x.into(), y))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 -             Box::new(SkipEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 89 +             Box::new(SkipEqualXY::new(x.into(), <u8 as Into<_>>::into(y)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:94:42
[INFO] [stdout]    |
[INFO] [stdout] 94 |             Box::new(SkipNotEqualXY::new(x.into(), y.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] 94 -             Box::new(SkipNotEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 94 +             Box::new(SkipNotEqualXY::new(x, y.into()))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -             Box::new(SkipNotEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 94 +             Box::new(SkipNotEqualXY::new(<u8 as Into<_>>::into(x), y.into()))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]   --> src/commands/command_parser.rs:94:52
[INFO] [stdout]    |
[INFO] [stdout] 94 |             Box::new(SkipNotEqualXY::new(x.into(), y.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] 94 -             Box::new(SkipNotEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 94 +             Box::new(SkipNotEqualXY::new(x.into(), y))
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -             Box::new(SkipNotEqualXY::new(x.into(), y.into()))
[INFO] [stdout] 94 +             Box::new(SkipNotEqualXY::new(x.into(), <u8 as Into<_>>::into(y)))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/commands/command_parser.rs:100:32
[INFO] [stdout]     |
[INFO] [stdout] 100 |             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout]     |                                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 100 -             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout] 100 +             Box::new(Draw::new(x, y.into(), bytes))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 -             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout] 100 +             Box::new(Draw::new(<u8 as Into<_>>::into(x), y.into(), bytes))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/commands/command_parser.rs:100:42
[INFO] [stdout]     |
[INFO] [stdout] 100 |             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout]     |                                          ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 100 -             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout] 100 +             Box::new(Draw::new(x.into(), y, bytes))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 -             Box::new(Draw::new(x.into(), y.into(), bytes))
[INFO] [stdout] 100 +             Box::new(Draw::new(x.into(), <u8 as Into<_>>::into(y), bytes))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `chip8` (bin "chip8" test) due to 65 previous errors; 2 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", kill_on_drop: false }`
[INFO] [stdout] 9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9
