[INFO] fetching crate vtil-parser 0.7.0...
[INFO] checking vtil-parser-0.7.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate vtil-parser 0.7.0 into /workspace/builds/worker-0-tc2/source
[INFO] started tweaking crates.io crate vtil-parser 0.7.0
[INFO] finished tweaking crates.io crate vtil-parser 0.7.0
[INFO] tweaked toml for crates.io crate vtil-parser 0.7.0 written to /workspace/builds/worker-0-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate vtil-parser 0.7.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate vtil-parser 0.7.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c
[INFO] running `Command { std: "docker" "start" "9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c", 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" "9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c", 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" "9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.26
[INFO] [stderr]    Compiling unicode-xid v0.2.2
[INFO] [stderr]    Compiling syn v1.0.71
[INFO] [stderr]    Compiling libc v0.2.94
[INFO] [stderr]    Compiling autocfg v1.0.1
[INFO] [stderr]    Compiling bitflags v1.2.1
[INFO] [stderr]     Checking hashbrown v0.9.1
[INFO] [stderr]     Checking scroll v0.10.2
[INFO] [stderr]    Compiling indexmap v1.6.2
[INFO] [stderr]     Checking memmap v0.7.0
[INFO] [stderr]    Compiling quote v1.0.9
[INFO] [stderr]    Compiling thiserror-impl v1.0.24
[INFO] [stderr]     Checking thiserror v1.0.24
[INFO] [stderr]     Checking vtil-parser v0.7.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: unused import: `serialize::*`
[INFO] [stdout]    --> src/lib.rs:100:9
[INFO] [stdout]     |
[INFO] [stdout] 100 | pub use serialize::*;
[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: `serialize::*`
[INFO] [stdout]    --> src/lib.rs:100:9
[INFO] [stdout]     |
[INFO] [stdout] 100 | pub use serialize::*;
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:139:48
[INFO] [stdout]     |
[INFO] [stdout] 139 |         insert_instr(self, Op::Mov(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 139 -         insert_instr(self, Op::Mov(op1.into(), op2.into()));
[INFO] [stdout] 139 +         insert_instr(self, Op::Mov(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 139 -         insert_instr(self, Op::Mov(op1.into(), op2.into()));
[INFO] [stdout] 139 +         insert_instr(self, Op::Mov(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:145:50
[INFO] [stdout]     |
[INFO] [stdout] 145 |         insert_instr(self, Op::Movsx(op1.into(), op2.into()));
[INFO] [stdout]     |                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 145 -         insert_instr(self, Op::Movsx(op1.into(), op2.into()));
[INFO] [stdout] 145 +         insert_instr(self, Op::Movsx(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 -         insert_instr(self, Op::Movsx(op1.into(), op2.into()));
[INFO] [stdout] 145 +         insert_instr(self, Op::Movsx(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:151:60
[INFO] [stdout]     |
[INFO] [stdout] 151 |         insert_instr(self, Op::Str(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 151 -         insert_instr(self, Op::Str(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 151 +         insert_instr(self, Op::Str(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 -         insert_instr(self, Op::Str(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 151 +         insert_instr(self, Op::Str(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:169:48
[INFO] [stdout]     |
[INFO] [stdout] 169 |         insert_instr(self, Op::Add(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 169 -         insert_instr(self, Op::Add(op1.into(), op2.into()));
[INFO] [stdout] 169 +         insert_instr(self, Op::Add(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 169 -         insert_instr(self, Op::Add(op1.into(), op2.into()));
[INFO] [stdout] 169 +         insert_instr(self, Op::Add(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:175:48
[INFO] [stdout]     |
[INFO] [stdout] 175 |         insert_instr(self, Op::Sub(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 175 -         insert_instr(self, Op::Sub(op1.into(), op2.into()));
[INFO] [stdout] 175 +         insert_instr(self, Op::Sub(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 175 -         insert_instr(self, Op::Sub(op1.into(), op2.into()));
[INFO] [stdout] 175 +         insert_instr(self, Op::Sub(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:181:48
[INFO] [stdout]     |
[INFO] [stdout] 181 |         insert_instr(self, Op::Mul(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 181 -         insert_instr(self, Op::Mul(op1.into(), op2.into()));
[INFO] [stdout] 181 +         insert_instr(self, Op::Mul(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 181 -         insert_instr(self, Op::Mul(op1.into(), op2.into()));
[INFO] [stdout] 181 +         insert_instr(self, Op::Mul(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:187:50
[INFO] [stdout]     |
[INFO] [stdout] 187 |         insert_instr(self, Op::Mulhi(op1.into(), op2.into()));
[INFO] [stdout]     |                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 187 -         insert_instr(self, Op::Mulhi(op1.into(), op2.into()));
[INFO] [stdout] 187 +         insert_instr(self, Op::Mulhi(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 -         insert_instr(self, Op::Mulhi(op1.into(), op2.into()));
[INFO] [stdout] 187 +         insert_instr(self, Op::Mulhi(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:193:49
[INFO] [stdout]     |
[INFO] [stdout] 193 |         insert_instr(self, Op::Imul(op1.into(), op2.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 193 -         insert_instr(self, Op::Imul(op1.into(), op2.into()));
[INFO] [stdout] 193 +         insert_instr(self, Op::Imul(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 -         insert_instr(self, Op::Imul(op1.into(), op2.into()));
[INFO] [stdout] 193 +         insert_instr(self, Op::Imul(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:199:51
[INFO] [stdout]     |
[INFO] [stdout] 199 |         insert_instr(self, Op::Imulhi(op1.into(), op2.into()));
[INFO] [stdout]     |                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 199 -         insert_instr(self, Op::Imulhi(op1.into(), op2.into()));
[INFO] [stdout] 199 +         insert_instr(self, Op::Imulhi(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 -         insert_instr(self, Op::Imulhi(op1.into(), op2.into()));
[INFO] [stdout] 199 +         insert_instr(self, Op::Imulhi(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:205:48
[INFO] [stdout]     |
[INFO] [stdout] 205 |         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 205 -         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 205 +         insert_instr(self, Op::Div(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 -         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 205 +         insert_instr(self, Op::Div(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:205:60
[INFO] [stdout]     |
[INFO] [stdout] 205 |         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 205 -         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 205 +         insert_instr(self, Op::Div(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 -         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 205 +         insert_instr(self, Op::Div(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:211:48
[INFO] [stdout]     |
[INFO] [stdout] 211 |         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 211 -         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 211 +         insert_instr(self, Op::Rem(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 -         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 211 +         insert_instr(self, Op::Rem(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:211:60
[INFO] [stdout]     |
[INFO] [stdout] 211 |         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 211 -         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 211 +         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 -         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 211 +         insert_instr(self, Op::Rem(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:217:49
[INFO] [stdout]     |
[INFO] [stdout] 217 |         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 217 +         insert_instr(self, Op::Idiv(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 217 +         insert_instr(self, Op::Idiv(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:217:61
[INFO] [stdout]     |
[INFO] [stdout] 217 |         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 217 +         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 217 +         insert_instr(self, Op::Idiv(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:223:49
[INFO] [stdout]     |
[INFO] [stdout] 223 |         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 223 -         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 223 +         insert_instr(self, Op::Irem(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 223 -         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 223 +         insert_instr(self, Op::Irem(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:223:61
[INFO] [stdout]     |
[INFO] [stdout] 223 |         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 223 -         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 223 +         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 223 -         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 223 +         insert_instr(self, Op::Irem(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:253:48
[INFO] [stdout]     |
[INFO] [stdout] 253 |         insert_instr(self, Op::Shr(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 253 -         insert_instr(self, Op::Shr(op1.into(), op2.into()));
[INFO] [stdout] 253 +         insert_instr(self, Op::Shr(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 -         insert_instr(self, Op::Shr(op1.into(), op2.into()));
[INFO] [stdout] 253 +         insert_instr(self, Op::Shr(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:259:48
[INFO] [stdout]     |
[INFO] [stdout] 259 |         insert_instr(self, Op::Shl(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 259 -         insert_instr(self, Op::Shl(op1.into(), op2.into()));
[INFO] [stdout] 259 +         insert_instr(self, Op::Shl(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 -         insert_instr(self, Op::Shl(op1.into(), op2.into()));
[INFO] [stdout] 259 +         insert_instr(self, Op::Shl(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:265:48
[INFO] [stdout]     |
[INFO] [stdout] 265 |         insert_instr(self, Op::Xor(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 265 -         insert_instr(self, Op::Xor(op1.into(), op2.into()));
[INFO] [stdout] 265 +         insert_instr(self, Op::Xor(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 265 -         insert_instr(self, Op::Xor(op1.into(), op2.into()));
[INFO] [stdout] 265 +         insert_instr(self, Op::Xor(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:271:47
[INFO] [stdout]     |
[INFO] [stdout] 271 |         insert_instr(self, Op::Or(op1.into(), op2.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 271 -         insert_instr(self, Op::Or(op1.into(), op2.into()));
[INFO] [stdout] 271 +         insert_instr(self, Op::Or(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 -         insert_instr(self, Op::Or(op1.into(), op2.into()));
[INFO] [stdout] 271 +         insert_instr(self, Op::Or(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:277:48
[INFO] [stdout]     |
[INFO] [stdout] 277 |         insert_instr(self, Op::And(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -         insert_instr(self, Op::And(op1.into(), op2.into()));
[INFO] [stdout] 277 +         insert_instr(self, Op::And(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -         insert_instr(self, Op::And(op1.into(), op2.into()));
[INFO] [stdout] 277 +         insert_instr(self, Op::And(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:283:48
[INFO] [stdout]     |
[INFO] [stdout] 283 |         insert_instr(self, Op::Ror(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 283 -         insert_instr(self, Op::Ror(op1.into(), op2.into()));
[INFO] [stdout] 283 +         insert_instr(self, Op::Ror(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 -         insert_instr(self, Op::Ror(op1.into(), op2.into()));
[INFO] [stdout] 283 +         insert_instr(self, Op::Ror(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:289:48
[INFO] [stdout]     |
[INFO] [stdout] 289 |         insert_instr(self, Op::Rol(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 289 -         insert_instr(self, Op::Rol(op1.into(), op2.into()));
[INFO] [stdout] 289 +         insert_instr(self, Op::Rol(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 289 -         insert_instr(self, Op::Rol(op1.into(), op2.into()));
[INFO] [stdout] 289 +         insert_instr(self, Op::Rol(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:295:47
[INFO] [stdout]     |
[INFO] [stdout] 295 |         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 295 -         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 295 +         insert_instr(self, Op::Tg(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 -         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 295 +         insert_instr(self, Op::Tg(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:295:59
[INFO] [stdout]     |
[INFO] [stdout] 295 |         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 295 -         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 295 +         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 -         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 295 +         insert_instr(self, Op::Tg(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:301:48
[INFO] [stdout]     |
[INFO] [stdout] 301 |         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 301 -         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 301 +         insert_instr(self, Op::Tge(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 301 -         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 301 +         insert_instr(self, Op::Tge(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:301:60
[INFO] [stdout]     |
[INFO] [stdout] 301 |         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 301 -         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 301 +         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 301 -         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 301 +         insert_instr(self, Op::Tge(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:307:47
[INFO] [stdout]     |
[INFO] [stdout] 307 |         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 307 -         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 307 +         insert_instr(self, Op::Te(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 -         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 307 +         insert_instr(self, Op::Te(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:307:59
[INFO] [stdout]     |
[INFO] [stdout] 307 |         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 307 -         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 307 +         insert_instr(self, Op::Te(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 -         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 307 +         insert_instr(self, Op::Te(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:313:48
[INFO] [stdout]     |
[INFO] [stdout] 313 |         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 313 -         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 313 +         insert_instr(self, Op::Tne(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 313 -         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 313 +         insert_instr(self, Op::Tne(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:313:60
[INFO] [stdout]     |
[INFO] [stdout] 313 |         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 313 -         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 313 +         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 313 -         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 313 +         insert_instr(self, Op::Tne(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:319:47
[INFO] [stdout]     |
[INFO] [stdout] 319 |         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 319 -         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 319 +         insert_instr(self, Op::Tl(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 -         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 319 +         insert_instr(self, Op::Tl(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:319:59
[INFO] [stdout]     |
[INFO] [stdout] 319 |         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 319 -         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 319 +         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 -         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 319 +         insert_instr(self, Op::Tl(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:325:48
[INFO] [stdout]     |
[INFO] [stdout] 325 |         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 325 -         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 325 +         insert_instr(self, Op::Tle(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 325 -         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 325 +         insert_instr(self, Op::Tle(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:325:60
[INFO] [stdout]     |
[INFO] [stdout] 325 |         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 325 -         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 325 +         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 325 -         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 325 +         insert_instr(self, Op::Tle(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:331:48
[INFO] [stdout]     |
[INFO] [stdout] 331 |         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 331 -         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 331 +         insert_instr(self, Op::Tug(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 331 -         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 331 +         insert_instr(self, Op::Tug(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:331:60
[INFO] [stdout]     |
[INFO] [stdout] 331 |         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 331 -         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 331 +         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 331 -         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 331 +         insert_instr(self, Op::Tug(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:337:49
[INFO] [stdout]     |
[INFO] [stdout] 337 |         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 337 -         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 337 +         insert_instr(self, Op::Tuge(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 -         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 337 +         insert_instr(self, Op::Tuge(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:337:61
[INFO] [stdout]     |
[INFO] [stdout] 337 |         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 337 -         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 337 +         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 -         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 337 +         insert_instr(self, Op::Tuge(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:343:48
[INFO] [stdout]     |
[INFO] [stdout] 343 |         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 343 +         insert_instr(self, Op::Tul(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 343 +         insert_instr(self, Op::Tul(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:343:60
[INFO] [stdout]     |
[INFO] [stdout] 343 |         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 343 +         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 343 +         insert_instr(self, Op::Tul(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:349:49
[INFO] [stdout]     |
[INFO] [stdout] 349 |         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 349 -         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 349 +         insert_instr(self, Op::Tule(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 -         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 349 +         insert_instr(self, Op::Tule(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:349:61
[INFO] [stdout]     |
[INFO] [stdout] 349 |         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 349 -         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 349 +         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 -         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 349 +         insert_instr(self, Op::Tule(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:355:48
[INFO] [stdout]     |
[INFO] [stdout] 355 |         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 355 -         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 355 +         insert_instr(self, Op::Ifs(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 355 -         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 355 +         insert_instr(self, Op::Ifs(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:355:60
[INFO] [stdout]     |
[INFO] [stdout] 355 |         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 355 -         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 355 +         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 355 -         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 355 +         insert_instr(self, Op::Ifs(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:361:47
[INFO] [stdout]     |
[INFO] [stdout] 361 |         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 361 -         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 361 +         insert_instr(self, Op::Js(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 -         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 361 +         insert_instr(self, Op::Js(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:361:59
[INFO] [stdout]     |
[INFO] [stdout] 361 |         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 361 -         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 361 +         insert_instr(self, Op::Js(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 -         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 361 +         insert_instr(self, Op::Js(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:367:36
[INFO] [stdout]     |
[INFO] [stdout] 367 |         insert_instr(self, Op::Jmp(op1.into()));
[INFO] [stdout]     |                                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 367 -         insert_instr(self, Op::Jmp(op1.into()));
[INFO] [stdout] 367 +         insert_instr(self, Op::Jmp(op1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 367 -         insert_instr(self, Op::Jmp(op1.into()));
[INFO] [stdout] 367 +         insert_instr(self, Op::Jmp(<pod::Operand as Into<_>>::into(op1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:373:38
[INFO] [stdout]     |
[INFO] [stdout] 373 |         insert_instr(self, Op::Vexit(op1.into()));
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 373 -         insert_instr(self, Op::Vexit(op1.into()));
[INFO] [stdout] 373 +         insert_instr(self, Op::Vexit(op1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 373 -         insert_instr(self, Op::Vexit(op1.into()));
[INFO] [stdout] 373 +         insert_instr(self, Op::Vexit(<pod::Operand as Into<_>>::into(op1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:379:39
[INFO] [stdout]     |
[INFO] [stdout] 379 |         insert_instr(self, Op::Vxcall(op1.into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 379 -         insert_instr(self, Op::Vxcall(op1.into()));
[INFO] [stdout] 379 +         insert_instr(self, Op::Vxcall(op1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 379 -         insert_instr(self, Op::Vxcall(op1.into()));
[INFO] [stdout] 379 +         insert_instr(self, Op::Vxcall(<pod::Operand as Into<_>>::into(op1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `vtil-parser` (lib) due to 51 previous errors; 1 warning emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:139:48
[INFO] [stdout]     |
[INFO] [stdout] 139 |         insert_instr(self, Op::Mov(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 139 -         insert_instr(self, Op::Mov(op1.into(), op2.into()));
[INFO] [stdout] 139 +         insert_instr(self, Op::Mov(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 139 -         insert_instr(self, Op::Mov(op1.into(), op2.into()));
[INFO] [stdout] 139 +         insert_instr(self, Op::Mov(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:145:50
[INFO] [stdout]     |
[INFO] [stdout] 145 |         insert_instr(self, Op::Movsx(op1.into(), op2.into()));
[INFO] [stdout]     |                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 145 -         insert_instr(self, Op::Movsx(op1.into(), op2.into()));
[INFO] [stdout] 145 +         insert_instr(self, Op::Movsx(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 -         insert_instr(self, Op::Movsx(op1.into(), op2.into()));
[INFO] [stdout] 145 +         insert_instr(self, Op::Movsx(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:151:60
[INFO] [stdout]     |
[INFO] [stdout] 151 |         insert_instr(self, Op::Str(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 151 -         insert_instr(self, Op::Str(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 151 +         insert_instr(self, Op::Str(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 -         insert_instr(self, Op::Str(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 151 +         insert_instr(self, Op::Str(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:169:48
[INFO] [stdout]     |
[INFO] [stdout] 169 |         insert_instr(self, Op::Add(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 169 -         insert_instr(self, Op::Add(op1.into(), op2.into()));
[INFO] [stdout] 169 +         insert_instr(self, Op::Add(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 169 -         insert_instr(self, Op::Add(op1.into(), op2.into()));
[INFO] [stdout] 169 +         insert_instr(self, Op::Add(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:175:48
[INFO] [stdout]     |
[INFO] [stdout] 175 |         insert_instr(self, Op::Sub(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 175 -         insert_instr(self, Op::Sub(op1.into(), op2.into()));
[INFO] [stdout] 175 +         insert_instr(self, Op::Sub(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 175 -         insert_instr(self, Op::Sub(op1.into(), op2.into()));
[INFO] [stdout] 175 +         insert_instr(self, Op::Sub(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:181:48
[INFO] [stdout]     |
[INFO] [stdout] 181 |         insert_instr(self, Op::Mul(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 181 -         insert_instr(self, Op::Mul(op1.into(), op2.into()));
[INFO] [stdout] 181 +         insert_instr(self, Op::Mul(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 181 -         insert_instr(self, Op::Mul(op1.into(), op2.into()));
[INFO] [stdout] 181 +         insert_instr(self, Op::Mul(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:187:50
[INFO] [stdout]     |
[INFO] [stdout] 187 |         insert_instr(self, Op::Mulhi(op1.into(), op2.into()));
[INFO] [stdout]     |                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 187 -         insert_instr(self, Op::Mulhi(op1.into(), op2.into()));
[INFO] [stdout] 187 +         insert_instr(self, Op::Mulhi(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 -         insert_instr(self, Op::Mulhi(op1.into(), op2.into()));
[INFO] [stdout] 187 +         insert_instr(self, Op::Mulhi(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:193:49
[INFO] [stdout]     |
[INFO] [stdout] 193 |         insert_instr(self, Op::Imul(op1.into(), op2.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 193 -         insert_instr(self, Op::Imul(op1.into(), op2.into()));
[INFO] [stdout] 193 +         insert_instr(self, Op::Imul(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 -         insert_instr(self, Op::Imul(op1.into(), op2.into()));
[INFO] [stdout] 193 +         insert_instr(self, Op::Imul(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:199:51
[INFO] [stdout]     |
[INFO] [stdout] 199 |         insert_instr(self, Op::Imulhi(op1.into(), op2.into()));
[INFO] [stdout]     |                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 199 -         insert_instr(self, Op::Imulhi(op1.into(), op2.into()));
[INFO] [stdout] 199 +         insert_instr(self, Op::Imulhi(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 -         insert_instr(self, Op::Imulhi(op1.into(), op2.into()));
[INFO] [stdout] 199 +         insert_instr(self, Op::Imulhi(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:205:48
[INFO] [stdout]     |
[INFO] [stdout] 205 |         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 205 -         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 205 +         insert_instr(self, Op::Div(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 -         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 205 +         insert_instr(self, Op::Div(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:205:60
[INFO] [stdout]     |
[INFO] [stdout] 205 |         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 205 -         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 205 +         insert_instr(self, Op::Div(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 -         insert_instr(self, Op::Div(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 205 +         insert_instr(self, Op::Div(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:211:48
[INFO] [stdout]     |
[INFO] [stdout] 211 |         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 211 -         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 211 +         insert_instr(self, Op::Rem(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 -         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 211 +         insert_instr(self, Op::Rem(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:211:60
[INFO] [stdout]     |
[INFO] [stdout] 211 |         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 211 -         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 211 +         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 -         insert_instr(self, Op::Rem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 211 +         insert_instr(self, Op::Rem(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:217:49
[INFO] [stdout]     |
[INFO] [stdout] 217 |         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 217 +         insert_instr(self, Op::Idiv(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 217 +         insert_instr(self, Op::Idiv(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:217:61
[INFO] [stdout]     |
[INFO] [stdout] 217 |         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 217 +         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -         insert_instr(self, Op::Idiv(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 217 +         insert_instr(self, Op::Idiv(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:223:49
[INFO] [stdout]     |
[INFO] [stdout] 223 |         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 223 -         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 223 +         insert_instr(self, Op::Irem(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 223 -         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 223 +         insert_instr(self, Op::Irem(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:223:61
[INFO] [stdout]     |
[INFO] [stdout] 223 |         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 223 -         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 223 +         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 223 -         insert_instr(self, Op::Irem(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 223 +         insert_instr(self, Op::Irem(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:253:48
[INFO] [stdout]     |
[INFO] [stdout] 253 |         insert_instr(self, Op::Shr(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 253 -         insert_instr(self, Op::Shr(op1.into(), op2.into()));
[INFO] [stdout] 253 +         insert_instr(self, Op::Shr(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 -         insert_instr(self, Op::Shr(op1.into(), op2.into()));
[INFO] [stdout] 253 +         insert_instr(self, Op::Shr(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:259:48
[INFO] [stdout]     |
[INFO] [stdout] 259 |         insert_instr(self, Op::Shl(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 259 -         insert_instr(self, Op::Shl(op1.into(), op2.into()));
[INFO] [stdout] 259 +         insert_instr(self, Op::Shl(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 -         insert_instr(self, Op::Shl(op1.into(), op2.into()));
[INFO] [stdout] 259 +         insert_instr(self, Op::Shl(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:265:48
[INFO] [stdout]     |
[INFO] [stdout] 265 |         insert_instr(self, Op::Xor(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 265 -         insert_instr(self, Op::Xor(op1.into(), op2.into()));
[INFO] [stdout] 265 +         insert_instr(self, Op::Xor(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 265 -         insert_instr(self, Op::Xor(op1.into(), op2.into()));
[INFO] [stdout] 265 +         insert_instr(self, Op::Xor(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:271:47
[INFO] [stdout]     |
[INFO] [stdout] 271 |         insert_instr(self, Op::Or(op1.into(), op2.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 271 -         insert_instr(self, Op::Or(op1.into(), op2.into()));
[INFO] [stdout] 271 +         insert_instr(self, Op::Or(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 -         insert_instr(self, Op::Or(op1.into(), op2.into()));
[INFO] [stdout] 271 +         insert_instr(self, Op::Or(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:277:48
[INFO] [stdout]     |
[INFO] [stdout] 277 |         insert_instr(self, Op::And(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -         insert_instr(self, Op::And(op1.into(), op2.into()));
[INFO] [stdout] 277 +         insert_instr(self, Op::And(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -         insert_instr(self, Op::And(op1.into(), op2.into()));
[INFO] [stdout] 277 +         insert_instr(self, Op::And(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:283:48
[INFO] [stdout]     |
[INFO] [stdout] 283 |         insert_instr(self, Op::Ror(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 283 -         insert_instr(self, Op::Ror(op1.into(), op2.into()));
[INFO] [stdout] 283 +         insert_instr(self, Op::Ror(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 283 -         insert_instr(self, Op::Ror(op1.into(), op2.into()));
[INFO] [stdout] 283 +         insert_instr(self, Op::Ror(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:289:48
[INFO] [stdout]     |
[INFO] [stdout] 289 |         insert_instr(self, Op::Rol(op1.into(), op2.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 289 -         insert_instr(self, Op::Rol(op1.into(), op2.into()));
[INFO] [stdout] 289 +         insert_instr(self, Op::Rol(op1.into(), op2));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 289 -         insert_instr(self, Op::Rol(op1.into(), op2.into()));
[INFO] [stdout] 289 +         insert_instr(self, Op::Rol(op1.into(), <pod::Operand as Into<_>>::into(op2)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:295:47
[INFO] [stdout]     |
[INFO] [stdout] 295 |         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 295 -         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 295 +         insert_instr(self, Op::Tg(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 -         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 295 +         insert_instr(self, Op::Tg(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:295:59
[INFO] [stdout]     |
[INFO] [stdout] 295 |         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 295 -         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 295 +         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 -         insert_instr(self, Op::Tg(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 295 +         insert_instr(self, Op::Tg(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:301:48
[INFO] [stdout]     |
[INFO] [stdout] 301 |         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 301 -         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 301 +         insert_instr(self, Op::Tge(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 301 -         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 301 +         insert_instr(self, Op::Tge(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:301:60
[INFO] [stdout]     |
[INFO] [stdout] 301 |         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 301 -         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 301 +         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 301 -         insert_instr(self, Op::Tge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 301 +         insert_instr(self, Op::Tge(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:307:47
[INFO] [stdout]     |
[INFO] [stdout] 307 |         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 307 -         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 307 +         insert_instr(self, Op::Te(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 -         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 307 +         insert_instr(self, Op::Te(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:307:59
[INFO] [stdout]     |
[INFO] [stdout] 307 |         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 307 -         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 307 +         insert_instr(self, Op::Te(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 -         insert_instr(self, Op::Te(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 307 +         insert_instr(self, Op::Te(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:313:48
[INFO] [stdout]     |
[INFO] [stdout] 313 |         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 313 -         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 313 +         insert_instr(self, Op::Tne(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 313 -         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 313 +         insert_instr(self, Op::Tne(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:313:60
[INFO] [stdout]     |
[INFO] [stdout] 313 |         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 313 -         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 313 +         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 313 -         insert_instr(self, Op::Tne(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 313 +         insert_instr(self, Op::Tne(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:319:47
[INFO] [stdout]     |
[INFO] [stdout] 319 |         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 319 -         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 319 +         insert_instr(self, Op::Tl(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 -         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 319 +         insert_instr(self, Op::Tl(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:319:59
[INFO] [stdout]     |
[INFO] [stdout] 319 |         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 319 -         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 319 +         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 -         insert_instr(self, Op::Tl(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 319 +         insert_instr(self, Op::Tl(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:325:48
[INFO] [stdout]     |
[INFO] [stdout] 325 |         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 325 -         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 325 +         insert_instr(self, Op::Tle(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 325 -         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 325 +         insert_instr(self, Op::Tle(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:325:60
[INFO] [stdout]     |
[INFO] [stdout] 325 |         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 325 -         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 325 +         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 325 -         insert_instr(self, Op::Tle(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 325 +         insert_instr(self, Op::Tle(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:331:48
[INFO] [stdout]     |
[INFO] [stdout] 331 |         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 331 -         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 331 +         insert_instr(self, Op::Tug(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 331 -         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 331 +         insert_instr(self, Op::Tug(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:331:60
[INFO] [stdout]     |
[INFO] [stdout] 331 |         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 331 -         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 331 +         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 331 -         insert_instr(self, Op::Tug(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 331 +         insert_instr(self, Op::Tug(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:337:49
[INFO] [stdout]     |
[INFO] [stdout] 337 |         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 337 -         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 337 +         insert_instr(self, Op::Tuge(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 -         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 337 +         insert_instr(self, Op::Tuge(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:337:61
[INFO] [stdout]     |
[INFO] [stdout] 337 |         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 337 -         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 337 +         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 -         insert_instr(self, Op::Tuge(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 337 +         insert_instr(self, Op::Tuge(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:343:48
[INFO] [stdout]     |
[INFO] [stdout] 343 |         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 343 +         insert_instr(self, Op::Tul(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 343 +         insert_instr(self, Op::Tul(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:343:60
[INFO] [stdout]     |
[INFO] [stdout] 343 |         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 343 +         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -         insert_instr(self, Op::Tul(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 343 +         insert_instr(self, Op::Tul(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:349:49
[INFO] [stdout]     |
[INFO] [stdout] 349 |         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 349 -         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 349 +         insert_instr(self, Op::Tule(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 -         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 349 +         insert_instr(self, Op::Tule(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:349:61
[INFO] [stdout]     |
[INFO] [stdout] 349 |         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 349 -         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 349 +         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 -         insert_instr(self, Op::Tule(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 349 +         insert_instr(self, Op::Tule(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:355:48
[INFO] [stdout]     |
[INFO] [stdout] 355 |         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 355 -         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 355 +         insert_instr(self, Op::Ifs(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 355 -         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 355 +         insert_instr(self, Op::Ifs(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:355:60
[INFO] [stdout]     |
[INFO] [stdout] 355 |         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 355 -         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 355 +         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 355 -         insert_instr(self, Op::Ifs(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 355 +         insert_instr(self, Op::Ifs(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:361:47
[INFO] [stdout]     |
[INFO] [stdout] 361 |         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 361 -         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 361 +         insert_instr(self, Op::Js(op1.into(), op2, op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 -         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 361 +         insert_instr(self, Op::Js(op1.into(), <pod::Operand as Into<_>>::into(op2), op3.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:361:59
[INFO] [stdout]     |
[INFO] [stdout] 361 |         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout]     |                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 361 -         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 361 +         insert_instr(self, Op::Js(op1.into(), op2.into(), op3));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 -         insert_instr(self, Op::Js(op1.into(), op2.into(), op3.into()));
[INFO] [stdout] 361 +         insert_instr(self, Op::Js(op1.into(), op2.into(), <pod::Operand as Into<_>>::into(op3)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:367:36
[INFO] [stdout]     |
[INFO] [stdout] 367 |         insert_instr(self, Op::Jmp(op1.into()));
[INFO] [stdout]     |                                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 367 -         insert_instr(self, Op::Jmp(op1.into()));
[INFO] [stdout] 367 +         insert_instr(self, Op::Jmp(op1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 367 -         insert_instr(self, Op::Jmp(op1.into()));
[INFO] [stdout] 367 +         insert_instr(self, Op::Jmp(<pod::Operand as Into<_>>::into(op1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:373:38
[INFO] [stdout]     |
[INFO] [stdout] 373 |         insert_instr(self, Op::Vexit(op1.into()));
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 373 -         insert_instr(self, Op::Vexit(op1.into()));
[INFO] [stdout] 373 +         insert_instr(self, Op::Vexit(op1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 373 -         insert_instr(self, Op::Vexit(op1.into()));
[INFO] [stdout] 373 +         insert_instr(self, Op::Vexit(<pod::Operand as Into<_>>::into(op1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `pod::Operand`
[INFO] [stdout]    --> src/instr_builder.rs:379:39
[INFO] [stdout]     |
[INFO] [stdout] 379 |         insert_instr(self, Op::Vxcall(op1.into()));
[INFO] [stdout]     |                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 379 -         insert_instr(self, Op::Vxcall(op1.into()));
[INFO] [stdout] 379 +         insert_instr(self, Op::Vxcall(op1));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 379 -         insert_instr(self, Op::Vxcall(op1.into()));
[INFO] [stdout] 379 +         insert_instr(self, Op::Vxcall(<pod::Operand as Into<_>>::into(op1)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `vtil-parser` (lib test) due to 51 previous errors; 1 warning emitted
[INFO] running `Command { std: "docker" "inspect" "9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c", kill_on_drop: false }`
[INFO] [stdout] 9a71da5b46bfaa3610aff0113e7a97521025cb17d7eeb7ddda27dd62ce87b88c
