[INFO] fetching crate snarkvm-synthesizer-program 4.12.0...
[INFO] checking snarkvm-synthesizer-program-4.12.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate snarkvm-synthesizer-program 4.12.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate snarkvm-synthesizer-program 4.12.0
[INFO] finished tweaking crates.io crate snarkvm-synthesizer-program 4.12.0
[INFO] tweaked toml for crates.io crate snarkvm-synthesizer-program 4.12.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate snarkvm-synthesizer-program 4.12.0 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate snarkvm-synthesizer-program 4.12.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" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:c0af3998e971868164375a7dfb646c9933ddd1a3bdb00fa2041266763dc1eeab" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 8fb0725c495f266b3d98746027e90c8eeb6686bd25cebbf937aab37baaf9fa21
[INFO] running `Command { std: "docker" "start" "8fb0725c495f266b3d98746027e90c8eeb6686bd25cebbf937aab37baaf9fa21", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "8fb0725c495f266b3d98746027e90c8eeb6686bd25cebbf937aab37baaf9fa21", 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" "8fb0725c495f266b3d98746027e90c8eeb6686bd25cebbf937aab37baaf9fa21" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "8fb0725c495f266b3d98746027e90c8eeb6686bd25cebbf937aab37baaf9fa21", 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" "8fb0725c495f266b3d98746027e90c8eeb6686bd25cebbf937aab37baaf9fa21" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]     Checking subtle v2.6.1
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]     Checking crossbeam-epoch v0.9.20
[INFO] [stderr]    Compiling serde_json v1.0.150
[INFO] [stderr]     Checking memchr v2.8.2
[INFO] [stderr]    Compiling aleo-std v1.0.4
[INFO] [stderr]    Compiling anyhow v1.0.103
[INFO] [stderr]     Checking getrandom v0.4.3
[INFO] [stderr]     Checking ctutils v0.4.2
[INFO] [stderr]     Checking chacha20 v0.10.2
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]    Compiling syn v3.0.6
[INFO] [stderr]    Compiling syn v1.0.109
[INFO] [stderr]     Checking crossbeam-deque v0.8.6
[INFO] [stderr]     Checking aleo-std-profiler v1.0.4
[INFO] [stderr]     Checking aleo-std-timer v1.0.4
[INFO] [stderr]     Checking rayon-core v1.13.0
[INFO] [stderr]     Checking aleo-std-cpu v1.0.4
[INFO] [stderr]     Checking num-bigint v0.4.8
[INFO] [stderr]     Checking rand v0.10.2
[INFO] [stderr]     Checking num_cpus v1.17.0
[INFO] [stderr]     Checking rand_xorshift v0.5.0
[INFO] [stderr]     Checking smol_str v0.2.2
[INFO] [stderr]     Checking rayon v1.12.0
[INFO] [stderr]     Checking itertools v0.14.0
[INFO] [stderr]     Checking nom v7.1.3
[INFO] [stderr]     Checking bech32 v0.11.1
[INFO] [stderr]    Compiling zerocopy v0.8.52
[INFO] [stderr]    Compiling cc v1.2.66
[INFO] [stderr]     Checking ff v0.14.0
[INFO] [stderr]     Checking group v0.14.0
[INFO] [stderr]    Compiling generic-array v0.14.9
[INFO] [stderr]     Checking base16ct v1.0.0
[INFO] [stderr]     Checking getrandom v0.2.17
[INFO] [stderr]    Compiling httparse v1.10.1
[INFO] [stderr]    Compiling crunchy v0.2.4
[INFO] [stderr]    Compiling rustls v0.23.45
[INFO] [stderr]     Checking http v1.4.2
[INFO] [stderr]     Checking parking_lot_core v0.9.12
[INFO] [stderr]    Compiling tiny-keccak v2.0.2
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]     Checking crypto-common v0.1.6
[INFO] [stderr]     Checking ureq-proto v0.6.4
[INFO] [stderr]     Checking block-buffer v0.10.4
[INFO] [stderr]    Compiling ahash v0.8.12
[INFO] [stderr]     Checking utf8-zero v0.8.1
[INFO] [stderr]    Compiling ring v0.17.14
[INFO] [stderr]     Checking constant_time_eq v0.4.2
[INFO] [stderr]     Checking digest v0.10.7
[INFO] [stderr]     Checking blake2s_simd v1.0.5
[INFO] [stderr]     Checking indexmap v2.14.0
[INFO] [stderr]     Checking blake2 v0.10.6
[INFO] [stderr]    Compiling snarkvm-circuit-environment-witness v4.12.0
[INFO] [stderr]    Compiling unicode-xid v0.0.4
[INFO] [stderr]     Checking bs58 v0.5.1
[INFO] [stderr]    Compiling synom v0.11.3
[INFO] [stderr]    Compiling quote v0.3.15
[INFO] [stderr]     Checking enum_index v0.2.0
[INFO] [stderr]     Checking clap_builder v4.6.0
[INFO] [stderr]     Checking regex-automata v0.4.14
[INFO] [stderr]    Compiling syn v0.11.11
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling snarkvm-utilities-derives v4.12.0
[INFO] [stderr]    Compiling enum_index_derive v0.2.0
[INFO] [stderr]     Checking criterion-plot v0.6.0
[INFO] [stderr]     Checking regex v1.12.4
[INFO] [stderr]     Checking plotters v0.3.7
[INFO] [stderr]    Compiling aleo-std-timed v1.0.4
[INFO] [stderr]    Compiling aleo-std-time v1.0.4
[INFO] [stderr]     Checking clap v4.6.1
[INFO] [stderr]    Compiling zeroize_derive v1.5.0
[INFO] [stderr]    Compiling tracing-attributes v0.1.31
[INFO] [stderr]    Compiling thiserror-impl v2.0.18
[INFO] [stderr]    Compiling zerocopy-derive v0.8.52
[INFO] [stderr]    Compiling enum-iterator-derive v1.5.0
[INFO] [stderr]     Checking zeroize v1.9.0
[INFO] [stderr]     Checking hybrid-array v0.4.13
[INFO] [stderr]     Checking der v0.8.2
[INFO] [stderr]     Checking rustls-pki-types v1.15.0
[INFO] [stderr]     Checking webpki-roots v1.0.8
[INFO] [stderr]     Checking enum-iterator v2.3.0
[INFO] [stderr]     Checking thiserror v2.0.18
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]    Compiling num-derive v0.4.2
[INFO] [stderr]     Checking serde v1.0.229
[INFO] [stderr]     Checking crypto-common v0.2.2
[INFO] [stderr]     Checking block-buffer v0.12.1
[INFO] [stderr]     Checking crypto-bigint v0.7.5
[INFO] [stderr]     Checking sec1 v0.8.1
[INFO] [stderr]     Checking rustls-webpki v0.103.15
[INFO] [stderr]     Checking bincode v1.3.3
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking digest v0.11.3
[INFO] [stderr]     Checking sha2 v0.11.0
[INFO] [stderr]     Checking hmac v0.13.0
[INFO] [stderr]     Checking signature v3.0.0
[INFO] [stderr]     Checking snarkvm-utilities v4.12.0
[INFO] [stderr]     Checking snarkvm-fields v4.12.0
[INFO] [stderr]     Checking snarkvm-curves v4.12.0
[INFO] [stderr]     Checking primefield v0.14.0
[INFO] [stderr]     Checking elliptic-curve v0.14.1
[INFO] [stderr]     Checking rfc6979 v0.6.0
[INFO] [stderr]     Checking wnaf v0.14.1
[INFO] [stderr]     Checking ureq v3.4.2
[INFO] [stderr]     Checking snarkvm-console-network-environment v4.12.0
[INFO] [stderr]     Checking primeorder v0.14.0
[INFO] [stderr]     Checking ecdsa v0.17.0
[INFO] [stderr]     Checking snarkvm-console-types-boolean v4.12.0
[INFO] [stderr]     Checking snarkvm-console-types-field v4.12.0
[INFO] [stderr]     Checking k256 v0.14.0
[INFO] [stderr]     Checking snarkvm-console-types-scalar v4.12.0
[INFO] [stderr]     Checking snarkvm-parameters v4.12.0
[INFO] [stderr]     Checking snarkvm-console-types-integers v4.12.0
[INFO] [stderr]     Checking snarkvm-console-types-group v4.12.0
[INFO] [stderr]     Checking snarkvm-console-types-address v4.12.0
[INFO] [stderr]     Checking snarkvm-console-types-string v4.12.0
[INFO] [stderr]     Checking snarkvm-console-types v4.12.0
[INFO] [stderr]     Checking snarkvm-console-algorithms v4.12.0
[INFO] [stderr]     Checking half v2.7.1
[INFO] [stderr]     Checking ppv-lite86 v0.2.21
[INFO] [stderr]     Checking snarkvm-console-collections v4.12.0
[INFO] [stderr]     Checking ciborium-ll v0.2.2
[INFO] [stderr]     Checking rand_chacha v0.10.0
[INFO] [stderr]     Checking ciborium v0.2.2
[INFO] [stderr]     Checking snarkvm-algorithms v4.12.0
[INFO] [stderr]     Checking criterion v0.7.0
[INFO] [stderr]     Checking snarkvm-console-network v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-environment v4.12.0
[INFO] [stderr]     Checking snarkvm-console-account v4.12.0
[INFO] [stderr]     Checking snarkvm-console-program v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-types-boolean v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-types-field v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-types-scalar v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-types-group v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-types-integers v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-types-address v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-types-string v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-types v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-algorithms v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-collections v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-network v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-account v4.12.0
[INFO] [stderr]     Checking snarkvm-console v4.12.0
[INFO] [stderr]     Checking snarkvm-synthesizer-error v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit-program v4.12.0
[INFO] [stderr]     Checking snarkvm-circuit v4.12.0
[INFO] [stderr]     Checking snarkvm-synthesizer-snark v4.12.0
[INFO] [stderr]     Checking snarkvm-synthesizer-program v4.12.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `snarkvm_synthesizer_error::EvalError`
[INFO] [stdout]    --> src/logic/instruction/mod.rs:604:42
[INFO] [stdout]     |
[INFO] [stdout] 604 |         instruction!(self, |instruction| instruction.evaluate(stack, registers).map_err(Into::into))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 604 -         instruction!(self, |instruction| instruction.evaluate(stack, registers).map_err(Into::into))
[INFO] [stdout] 604 +         instruction!(self, |instruction| instruction.evaluate(stack, registers))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `snarkvm_synthesizer_error::ExecError`
[INFO] [stdout]    --> src/logic/instruction/mod.rs:616:42
[INFO] [stdout]     |
[INFO] [stdout] 616 |         instruction!(self, |instruction| instruction.execute::<A>(stack, registers).map_err(Into::into))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 616 -         instruction!(self, |instruction| instruction.execute::<A>(stack, registers).map_err(Into::into))
[INFO] [stdout] 616 +         instruction!(self, |instruction| instruction.execute::<A>(stack, registers))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `snarkvm_synthesizer_error::FinalizeError`
[INFO] [stdout]    --> src/logic/instruction/mod.rs:629:42
[INFO] [stdout]     |
[INFO] [stdout] 629 |         instruction!(self, |instruction| instruction.finalize(stack, store, registers).map_err(Into::into))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 629 -         instruction!(self, |instruction| instruction.finalize(stack, store, registers).map_err(Into::into))
[INFO] [stdout] 629 +         instruction!(self, |instruction| instruction.finalize(stack, store, registers))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `snarkvm-synthesizer-program` (lib) due to 3 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `snarkvm_synthesizer_error::EvalError`
[INFO] [stdout]    --> src/logic/instruction/mod.rs:604:42
[INFO] [stdout]     |
[INFO] [stdout] 604 |         instruction!(self, |instruction| instruction.evaluate(stack, registers).map_err(Into::into))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 604 -         instruction!(self, |instruction| instruction.evaluate(stack, registers).map_err(Into::into))
[INFO] [stdout] 604 +         instruction!(self, |instruction| instruction.evaluate(stack, registers))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `snarkvm_synthesizer_error::ExecError`
[INFO] [stdout]    --> src/logic/instruction/mod.rs:616:42
[INFO] [stdout]     |
[INFO] [stdout] 616 |         instruction!(self, |instruction| instruction.execute::<A>(stack, registers).map_err(Into::into))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 616 -         instruction!(self, |instruction| instruction.execute::<A>(stack, registers).map_err(Into::into))
[INFO] [stdout] 616 +         instruction!(self, |instruction| instruction.execute::<A>(stack, registers))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `snarkvm_synthesizer_error::FinalizeError`
[INFO] [stdout]    --> src/logic/instruction/mod.rs:629:42
[INFO] [stdout]     |
[INFO] [stdout] 629 |         instruction!(self, |instruction| instruction.finalize(stack, store, registers).map_err(Into::into))
[INFO] [stdout]     |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 629 -         instruction!(self, |instruction| instruction.finalize(stack, store, registers).map_err(Into::into))
[INFO] [stdout] 629 +         instruction!(self, |instruction| instruction.finalize(stack, store, registers))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:85:1
[INFO] [stdout]     |
[INFO] [stdout]  85 | / crate::operation!(
[INFO] [stdout]  86 | |     pub struct AbsOperation<console::prelude::AbsChecked, circuit::traits::AbsChecked, abs_checked, "abs"> {
[INFO] [stdout]  87 | |         I8 => I8 ("ensure overflows halt"),
[INFO] [stdout]  88 | |         I16 => I16 ("ensure overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout]  93 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:85:1
[INFO] [stdout]     |
[INFO] [stdout]  85 | / crate::operation!(
[INFO] [stdout]  86 | |     pub struct AbsOperation<console::prelude::AbsChecked, circuit::traits::AbsChecked, abs_checked, "abs"> {
[INFO] [stdout]  87 | |         I8 => I8 ("ensure overflows halt"),
[INFO] [stdout]  88 | |         I16 => I16 ("ensure overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout]  93 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:85:1
[INFO] [stdout]     |
[INFO] [stdout]  85 | / crate::operation!(
[INFO] [stdout]  86 | |     pub struct AbsOperation<console::prelude::AbsChecked, circuit::traits::AbsChecked, abs_checked, "abs"> {
[INFO] [stdout]  87 | |         I8 => I8 ("ensure overflows halt"),
[INFO] [stdout]  88 | |         I16 => I16 ("ensure overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout]  93 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:85:1
[INFO] [stdout]     |
[INFO] [stdout]  85 | / crate::operation!(
[INFO] [stdout]  86 | |     pub struct AbsOperation<console::prelude::AbsChecked, circuit::traits::AbsChecked, abs_checked, "abs"> {
[INFO] [stdout]  87 | |         I8 => I8 ("ensure overflows halt"),
[INFO] [stdout]  88 | |         I16 => I16 ("ensure overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout]  93 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:85:1
[INFO] [stdout]     |
[INFO] [stdout]  85 | / crate::operation!(
[INFO] [stdout]  86 | |     pub struct AbsOperation<console::prelude::AbsChecked, circuit::traits::AbsChecked, abs_checked, "abs"> {
[INFO] [stdout]  87 | |         I8 => I8 ("ensure overflows halt"),
[INFO] [stdout]  88 | |         I16 => I16 ("ensure overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout]  93 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | / crate::operation!(
[INFO] [stdout]  99 | |     pub struct AbsWrappedOperation<console::prelude::AbsWrapped, circuit::traits::AbsWrapped, abs_wrapped, "abs.w"> {
[INFO] [stdout] 100 | |         I8 => I8,
[INFO] [stdout] 101 | |         I16 => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 106 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | / crate::operation!(
[INFO] [stdout]  99 | |     pub struct AbsWrappedOperation<console::prelude::AbsWrapped, circuit::traits::AbsWrapped, abs_wrapped, "abs.w"> {
[INFO] [stdout] 100 | |         I8 => I8,
[INFO] [stdout] 101 | |         I16 => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 106 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | / crate::operation!(
[INFO] [stdout]  99 | |     pub struct AbsWrappedOperation<console::prelude::AbsWrapped, circuit::traits::AbsWrapped, abs_wrapped, "abs.w"> {
[INFO] [stdout] 100 | |         I8 => I8,
[INFO] [stdout] 101 | |         I16 => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 106 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | / crate::operation!(
[INFO] [stdout]  99 | |     pub struct AbsWrappedOperation<console::prelude::AbsWrapped, circuit::traits::AbsWrapped, abs_wrapped, "abs.w"> {
[INFO] [stdout] 100 | |         I8 => I8,
[INFO] [stdout] 101 | |         I16 => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 106 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | / crate::operation!(
[INFO] [stdout]  99 | |     pub struct AbsWrappedOperation<console::prelude::AbsWrapped, circuit::traits::AbsWrapped, abs_wrapped, "abs.w"> {
[INFO] [stdout] 100 | |         I8 => I8,
[INFO] [stdout] 101 | |         I16 => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 106 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:111:1
[INFO] [stdout]     |
[INFO] [stdout] 111 | / crate::operation!(
[INFO] [stdout] 112 | |     pub struct AddOperation<core::ops::Add, core::ops::Add, add, "add"> {
[INFO] [stdout] 113 | |         (Field, Field) => Field,
[INFO] [stdout] 114 | |         (Group, Group) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 127 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:132:1
[INFO] [stdout]     |
[INFO] [stdout] 132 | / crate::operation!(
[INFO] [stdout] 133 | |     pub struct AddWrappedOperation<console::prelude::AddWrapped, circuit::traits::AddWrapped, add_wrapped, "add.w"> {
[INFO] [stdout] 134 | |         (I8, I8) => I8,
[INFO] [stdout] 135 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 145 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:150:1
[INFO] [stdout]     |
[INFO] [stdout] 150 | / crate::operation!(
[INFO] [stdout] 151 | |     pub struct AndOperation<core::ops::BitAnd, core::ops::BitAnd, bitand, "and"> {
[INFO] [stdout] 152 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 153 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 164 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:169:1
[INFO] [stdout]     |
[INFO] [stdout] 169 | / crate::operation!(
[INFO] [stdout] 170 | |     pub struct DivOperation<core::ops::Div, core::ops::Div, div, "div"> {
[INFO] [stdout] 171 | |         (Field, Field) => Field ("ensure divide by zero halts"),
[INFO] [stdout] 172 | |         (I8, I8) => I8 ("ensure overflows halt", "ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 184 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:189:1
[INFO] [stdout]     |
[INFO] [stdout] 189 | / crate::operation!(
[INFO] [stdout] 190 | |     pub struct DivWrappedOperation<console::prelude::DivWrapped, circuit::traits::DivWrapped, div_wrapped, "div.w"> {
[INFO] [stdout] 191 | |         (I8, I8) => I8 ("ensure divide by zero halts"),
[INFO] [stdout] 192 | |         (I16, I16) => I16 ("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 202 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:207:1
[INFO] [stdout]     |
[INFO] [stdout] 207 | / crate::operation!(
[INFO] [stdout] 208 | |     pub struct DoubleOperation<console::prelude::Double, circuit::traits::Double, double, "double"> {
[INFO] [stdout] 209 | |         Field => Field,
[INFO] [stdout] 210 | |         Group => Group,
[INFO] [stdout] 211 | |     }
[INFO] [stdout] 212 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:207:1
[INFO] [stdout]     |
[INFO] [stdout] 207 | / crate::operation!(
[INFO] [stdout] 208 | |     pub struct DoubleOperation<console::prelude::Double, circuit::traits::Double, double, "double"> {
[INFO] [stdout] 209 | |         Field => Field,
[INFO] [stdout] 210 | |         Group => Group,
[INFO] [stdout] 211 | |     }
[INFO] [stdout] 212 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:217:1
[INFO] [stdout]     |
[INFO] [stdout] 217 | / crate::operation!(
[INFO] [stdout] 218 | |     pub struct GreaterThanOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than, "gt"> {
[INFO] [stdout] 219 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 220 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 233 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:238:1
[INFO] [stdout]     |
[INFO] [stdout] 238 | / crate::operation!(
[INFO] [stdout] 239 | |     pub struct GreaterThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_greater_than_or_equal, "gte"> {
[INFO] [stdout] 240 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 241 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 254 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:259:1
[INFO] [stdout]     |
[INFO] [stdout] 259 | / crate::operation!(
[INFO] [stdout] 260 | |     pub struct InvOperation<console::prelude::Inverse, circuit::traits::Inverse, inverse?, "inv"> {
[INFO] [stdout] 261 | |         Field => Field ("ensure inverse of zero halts"),
[INFO] [stdout] 262 | |     }
[INFO] [stdout] 263 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:268:1
[INFO] [stdout]     |
[INFO] [stdout] 268 | / crate::operation!(
[INFO] [stdout] 269 | |     pub struct LessThanOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than, "lt"> {
[INFO] [stdout] 270 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 271 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 284 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:289:1
[INFO] [stdout]     |
[INFO] [stdout] 289 | / crate::operation!(
[INFO] [stdout] 290 | |     pub struct LessThanOrEqualOperation<console::prelude::Compare, circuit::traits::Compare, is_less_than_or_equal, "lte"> {
[INFO] [stdout] 291 | |         // (Address, Address) => Boolean,
[INFO] [stdout] 292 | |         (Field, Field) => Boolean,
[INFO] [stdout] ...   |
[INFO] [stdout] 305 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:310:1
[INFO] [stdout]     |
[INFO] [stdout] 310 | / crate::operation!(
[INFO] [stdout] 311 | |     pub struct ModuloOperation<console::prelude::Modulo, circuit::traits::Modulo, modulo, "mod"> {
[INFO] [stdout] 312 | |         (U8, U8) => U8("ensure divide by zero halts"),
[INFO] [stdout] 313 | |         (U16, U16) => U16("ensure divide by zero halts"),
[INFO] [stdout] ...   |
[INFO] [stdout] 318 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:323:1
[INFO] [stdout]     |
[INFO] [stdout] 323 | / crate::operation!(
[INFO] [stdout] 324 | |     pub struct MulOperation<core::ops::Mul, core::ops::Mul, mul, "mul"> {
[INFO] [stdout] 325 | |         (Field, Field) => Field,
[INFO] [stdout] 326 | |         (Group, Scalar) => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 340 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:345:1
[INFO] [stdout]     |
[INFO] [stdout] 345 | / crate::operation!(
[INFO] [stdout] 346 | |     pub struct MulWrappedOperation<console::prelude::MulWrapped, circuit::traits::MulWrapped, mul_wrapped, "mul.w"> {
[INFO] [stdout] 347 | |         (I8, I8) => I8,
[INFO] [stdout] 348 | |         (I16, I16) => I16,
[INFO] [stdout] ...   |
[INFO] [stdout] 358 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:363:1
[INFO] [stdout]     |
[INFO] [stdout] 363 | / crate::operation!(
[INFO] [stdout] 364 | |     pub struct NandOperation<console::prelude::Nand, circuit::traits::Nand, nand, "nand"> {
[INFO] [stdout] 365 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 366 | |     }
[INFO] [stdout] 367 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:363:1
[INFO] [stdout]     |
[INFO] [stdout] 363 | / crate::operation!(
[INFO] [stdout] 364 | |     pub struct NandOperation<console::prelude::Nand, circuit::traits::Nand, nand, "nand"> {
[INFO] [stdout] 365 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 366 | |     }
[INFO] [stdout] 367 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:372:1
[INFO] [stdout]     |
[INFO] [stdout] 372 | / crate::operation!(
[INFO] [stdout] 373 | |     pub struct NegOperation<core::ops::Neg, core::ops::Neg, neg, "neg"> {
[INFO] [stdout] 374 | |         Field => Field,
[INFO] [stdout] 375 | |         Group => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 382 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:372:1
[INFO] [stdout]     |
[INFO] [stdout] 372 | / crate::operation!(
[INFO] [stdout] 373 | |     pub struct NegOperation<core::ops::Neg, core::ops::Neg, neg, "neg"> {
[INFO] [stdout] 374 | |         Field => Field,
[INFO] [stdout] 375 | |         Group => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 382 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:372:1
[INFO] [stdout]     |
[INFO] [stdout] 372 | / crate::operation!(
[INFO] [stdout] 373 | |     pub struct NegOperation<core::ops::Neg, core::ops::Neg, neg, "neg"> {
[INFO] [stdout] 374 | |         Field => Field,
[INFO] [stdout] 375 | |         Group => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 382 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:372:1
[INFO] [stdout]     |
[INFO] [stdout] 372 | / crate::operation!(
[INFO] [stdout] 373 | |     pub struct NegOperation<core::ops::Neg, core::ops::Neg, neg, "neg"> {
[INFO] [stdout] 374 | |         Field => Field,
[INFO] [stdout] 375 | |         Group => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 382 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:372:1
[INFO] [stdout]     |
[INFO] [stdout] 372 | / crate::operation!(
[INFO] [stdout] 373 | |     pub struct NegOperation<core::ops::Neg, core::ops::Neg, neg, "neg"> {
[INFO] [stdout] 374 | |         Field => Field,
[INFO] [stdout] 375 | |         Group => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 382 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:372:1
[INFO] [stdout]     |
[INFO] [stdout] 372 | / crate::operation!(
[INFO] [stdout] 373 | |     pub struct NegOperation<core::ops::Neg, core::ops::Neg, neg, "neg"> {
[INFO] [stdout] 374 | |         Field => Field,
[INFO] [stdout] 375 | |         Group => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 382 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:372:1
[INFO] [stdout]     |
[INFO] [stdout] 372 | / crate::operation!(
[INFO] [stdout] 373 | |     pub struct NegOperation<core::ops::Neg, core::ops::Neg, neg, "neg"> {
[INFO] [stdout] 374 | |         Field => Field,
[INFO] [stdout] 375 | |         Group => Group,
[INFO] [stdout] ...   |
[INFO] [stdout] 382 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:387:1
[INFO] [stdout]     |
[INFO] [stdout] 387 | / crate::operation!(
[INFO] [stdout] 388 | |     pub struct NorOperation<console::prelude::Nor, circuit::traits::Nor, nor, "nor"> {
[INFO] [stdout] 389 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 390 | |     }
[INFO] [stdout] 391 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:387:1
[INFO] [stdout]     |
[INFO] [stdout] 387 | / crate::operation!(
[INFO] [stdout] 388 | |     pub struct NorOperation<console::prelude::Nor, circuit::traits::Nor, nor, "nor"> {
[INFO] [stdout] 389 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 390 | |     }
[INFO] [stdout] 391 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:595:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+...
[INFO] [stdout] ...   |
[INFO] [stdout] 595 | |                         <$operation as $crate::Operation<_, _, _, 1>>::output_type(&[console::program::LiteralType::$input.into()])?
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:396:1
[INFO] [stdout]     |
[INFO] [stdout] 396 | / crate::operation!(
[INFO] [stdout] 397 | |     pub struct NotOperation<core::ops::Not, core::ops::Not, not, "not"> {
[INFO] [stdout] 398 | |         Boolean => Boolean,
[INFO] [stdout] 399 | |         I8 => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 410 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 | / crate::operation!(
[INFO] [stdout] 416 | |     pub struct OrOperation<core::ops::BitOr, core::ops::BitOr, bitor, "or"> {
[INFO] [stdout] 417 | |         (Boolean, Boolean) => Boolean,
[INFO] [stdout] 418 | |         (I8, I8) => I8,
[INFO] [stdout] ...   |
[INFO] [stdout] 429 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[INFO] [stdout]     | |                                                                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:117
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }...
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), c...
[INFO] [stdout]     | |                                                                                                                     ^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 969 | |         };
[INFO] [stdout] 970 | |     }
[INFO] [stdout]     | |_____- this error originates in the macro `$crate::test_execute` which comes from the expansion of the macro `crate::operation`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/logic/instruction/operation/mod.rs:434:1
[INFO] [stdout]     |
[INFO] [stdout] 434 | / crate::operation!(
[INFO] [stdout] 435 | |     pub struct PowOperation<console::prelude::Pow, circuit::traits::Pow, pow, "pow"> {
[INFO] [stdout] 436 | |         (Field, Field) => Field,
[INFO] [stdout] 437 | |         (I8, U8) => I8 ("ensure exponentiation overflows halt"),
[INFO] [stdout] ...   |
[INFO] [stdout] 468 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<console::snarkvm_console_program::LiteralType as Into<console::snarkvm_console_program::LiteralType>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `console::snarkvm_console_program::LiteralType`
[INFO] [stdout]    --> src/logic/instruction/operation/macros.rs:705:165
[INFO] [stdout]     |
[INFO] [stdout] 395 | /     macro_rules! test_execute {
[INFO] [stdout] 396 | |         // Case 0: Unary operation.
[INFO] [stdout] 397 | |         ($operator:tt::$operate:tt == $operation:tt::$execute:tt { $( ($input:ident) => $output:ident $( ($($condition:tt),+) )?, )+ }) => {
[INFO] [stdout] ...   |
[INFO] [stdout] 705 | |                         <$operation as $crate::Operation<_, _, _, 2>>::output_type(&[console::program::LiteralType::$input_a.into(), console::program::LiteralType::$input_b.into()])?
[WARN] too many lines in the log, truncating it
