[INFO] fetching crate bevy_reflect_bms_bindings 0.23.0...
[INFO] checking bevy_reflect_bms_bindings-0.23.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate bevy_reflect_bms_bindings 0.23.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate bevy_reflect_bms_bindings 0.23.0
[INFO] finished tweaking crates.io crate bevy_reflect_bms_bindings 0.23.0
[INFO] tweaked toml for crates.io crate bevy_reflect_bms_bindings 0.23.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate bevy_reflect_bms_bindings 0.23.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate bevy_reflect_bms_bindings 0.23.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]    --> Cargo.toml:112:12
[INFO] [stderr]     |
[INFO] [stderr] 112 | homepage = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 117 | repository = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |              -----------------------------------------------
[INFO] [stderr]     |
[INFO] [stderr]     = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `bevy_reflect_bms_bindings` (manifest) generated 1 warning
[INFO] [stderr]     Blocking waiting for file lock on package cache
[ERROR] error running command: no output for 300 seconds
[INFO] checking bevy_reflect_bms_bindings-0.23.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate bevy_reflect_bms_bindings 0.23.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate bevy_reflect_bms_bindings 0.23.0
[INFO] finished tweaking crates.io crate bevy_reflect_bms_bindings 0.23.0
[INFO] tweaked toml for crates.io crate bevy_reflect_bms_bindings 0.23.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate bevy_reflect_bms_bindings 0.23.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate bevy_reflect_bms_bindings 0.23.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]    --> Cargo.toml:112:12
[INFO] [stderr]     |
[INFO] [stderr] 112 | homepage = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 117 | repository = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |              -----------------------------------------------
[INFO] [stderr]     |
[INFO] [stderr]     = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `bevy_reflect_bms_bindings` (manifest) generated 1 warning
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded variadics_please v2.0.0
[INFO] [stderr]   Downloaded inventory v0.3.25
[INFO] [stderr]   Downloaded bevy_mod_scripting_bindings v0.23.0
[INFO] [stderr]   Downloaded bevy_reflect_derive v0.20.0
[INFO] [stderr]   Downloaded disqualified v1.1.0
[INFO] [stderr]   Downloaded bevy_macro_utils v0.20.0
[INFO] [stderr]   Downloaded dot-writer v0.1.4
[INFO] [stderr]   Downloaded stackfuture v0.3.1
[INFO] [stderr]   Downloaded bevy_asset_macros v0.20.0
[INFO] [stderr]   Downloaded bevy_mod_scripting_display v0.23.0
[INFO] [stderr]   Downloaded atomicow v1.2.0
[INFO] [stderr]   Downloaded bevy_ptr v0.20.0
[INFO] [stderr]   Downloaded bevy_mod_scripting_derive v0.23.0
[INFO] [stderr]   Downloaded bevy_system_reflection v0.23.0
[INFO] [stderr]   Downloaded bevy_ecs_macros v0.20.0
[INFO] [stderr]   Downloaded bevy_mod_scripting_world v0.23.0
[INFO] [stderr]   Downloaded bevy_mod_scripting_script v0.23.0
[INFO] [stderr]   Downloaded bevy_mod_scripting_asset v0.23.0
[INFO] [stderr]   Downloaded spin v0.12.3
[INFO] [stderr]   Downloaded bevy_android v0.20.0
[INFO] [stderr]   Downloaded bevy_platform v0.20.0
[INFO] [stderr]   Downloaded bevy_mod_scripting_core v0.23.0
[INFO] [stderr]   Downloaded tracing-oslog v0.3.0
[INFO] [stderr]   Downloaded bevy_utils v0.20.0
[INFO] [stderr]   Downloaded bevy_log v0.20.0
[INFO] [stderr]   Downloaded bevy_ecs_macro_logic v0.20.0
[INFO] [stderr]   Downloaded bevy_app v0.20.0
[INFO] [stderr]   Downloaded bevy_mod_scripting_bindings_domain v0.23.0
[INFO] [stderr]   Downloaded glam v0.33.12
[INFO] [stderr]   Downloaded bevy_ecs v0.20.0
[INFO] [stderr]   Downloaded bevy_derive v0.20.0
[INFO] [stderr]   Downloaded bevy_reflect v0.20.0
[INFO] [stderr]   Downloaded bevy_diagnostic v0.20.0
[INFO] [stderr]   Downloaded bevy_time v0.20.0
[INFO] [stderr]   Downloaded bevy_tasks v0.20.0
[INFO] [stderr]   Downloaded cc v1.8.0
[INFO] [stderr]   Downloaded bevy_asset v0.20.0
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 7d688e29c175c04c92d8cfdc5c5bd40a0e0d6e45c810428131369cda5a25b5f3
[INFO] running `Command { std: "docker" "start" "7d688e29c175c04c92d8cfdc5c5bd40a0e0d6e45c810428131369cda5a25b5f3", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "7d688e29c175c04c92d8cfdc5c5bd40a0e0d6e45c810428131369cda5a25b5f3", 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" "7d688e29c175c04c92d8cfdc5c5bd40a0e0d6e45c810428131369cda5a25b5f3" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "7d688e29c175c04c92d8cfdc5c5bd40a0e0d6e45c810428131369cda5a25b5f3", 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" "7d688e29c175c04c92d8cfdc5c5bd40a0e0d6e45c810428131369cda5a25b5f3" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]    --> Cargo.toml:112:12
[INFO] [stderr]     |
[INFO] [stderr] 112 | homepage = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 117 | repository = "https://github.com/makspll/bevy_mod_scripting"
[INFO] [stderr]     |              -----------------------------------------------
[INFO] [stderr]     |
[INFO] [stderr]     = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `bevy_reflect_bms_bindings` (manifest) generated 1 warning
[INFO] [stderr]    Compiling serde v1.0.229
[INFO] [stderr]    Compiling libc v0.2.190
[INFO] [stderr]     Checking foldhash v0.2.0
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]    Compiling winnow v1.0.4
[INFO] [stderr]     Checking event-listener v5.4.2
[INFO] [stderr]    Compiling toml_datetime v1.1.2+spec-1.1.0
[INFO] [stderr]    Compiling thiserror v2.0.21
[INFO] [stderr]     Checking spin v0.12.3
[INFO] [stderr]     Checking bitflags v2.13.2
[INFO] [stderr]     Checking hashbrown v0.16.1
[INFO] [stderr]     Checking smallvec v1.16.3
[INFO] [stderr]    Compiling mutants v0.0.3
[INFO] [stderr]    Compiling erased-serde v0.4.10
[INFO] [stderr]    Compiling cfg_aliases v0.2.2
[INFO] [stderr]     Checking raw-window-handle v0.6.2
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]    Compiling nix v0.31.3
[INFO] [stderr]     Checking disqualified v1.1.0
[INFO] [stderr]     Checking glam v0.33.12
[INFO] [stderr]     Checking crossbeam-queue v0.3.14
[INFO] [stderr]     Checking downcast-rs v2.0.2
[INFO] [stderr]     Checking event-listener-strategy v0.5.4
[INFO] [stderr]     Checking inventory v0.3.25
[INFO] [stderr]     Checking bevy_ptr v0.20.0
[INFO] [stderr]     Checking arrayvec v0.7.8
[INFO] [stderr]     Checking nonmax v0.5.5
[INFO] [stderr]     Checking bumpalo v3.20.3
[INFO] [stderr]     Checking regex-syntax v0.8.11
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]    Compiling rustix v1.1.5
[INFO] [stderr]    Compiling cc v1.8.0
[INFO] [stderr]     Checking async-channel v2.5.0
[INFO] [stderr]     Checking const_panic v0.2.17
[INFO] [stderr]     Checking async-lock v3.4.2
[INFO] [stderr]     Checking futures-task v0.3.34
[INFO] [stderr]     Checking blocking v1.7.0
[INFO] [stderr]     Checking constant_time_eq v0.4.2
[INFO] [stderr]     Checking async-broadcast v0.7.2
[INFO] [stderr]     Checking crossbeam-channel v0.5.17
[INFO] [stderr]     Checking atomicow v1.2.0
[INFO] [stderr]     Checking dot-writer v0.1.4
[INFO] [stderr]     Checking itertools v0.14.0
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling unsynn v0.3.0
[INFO] [stderr]     Checking stackfuture v0.3.1
[INFO] [stderr]     Checking async-fs v2.2.0
[INFO] [stderr]     Checking indexmap v2.14.2
[INFO] [stderr]    Compiling syn v3.0.9
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]    Compiling blake3 v1.8.7
[INFO] [stderr]    Compiling variadics_please v2.0.0
[INFO] [stderr]    Compiling toml_parser v1.1.5+spec-1.1.0
[INFO] [stderr]    Compiling toml_edit v0.25.17+spec-1.1.0
[INFO] [stderr]     Checking getrandom v0.4.3
[INFO] [stderr]     Checking parking_lot_core v0.9.12
[INFO] [stderr]     Checking uuid v1.28.0
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]     Checking ctrlc v3.5.2
[INFO] [stderr]     Checking matchers v0.2.0
[INFO] [stderr]     Checking tracing-subscriber v0.3.23
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling bytemuck_derive v1.12.1
[INFO] [stderr]    Compiling thiserror-impl v2.0.21
[INFO] [stderr]    Compiling futures-macro v0.3.34
[INFO] [stderr]     Checking polling v3.11.0
[INFO] [stderr]     Checking async-io v2.6.0
[INFO] [stderr]     Checking futures-util v0.3.34
[INFO] [stderr]     Checking bytemuck v1.25.2
[INFO] [stderr]    Compiling bevy_macro_utils v0.20.0
[INFO] [stderr]    Compiling bevy_ecs_macro_logic v0.20.0
[INFO] [stderr]    Compiling derive_more-impl v2.1.1
[INFO] [stderr]    Compiling assert_type_match v0.1.1
[INFO] [stderr]    Compiling bevy_reflect_derive v0.20.0
[INFO] [stderr]    Compiling bevy_ecs_macros v0.20.0
[INFO] [stderr]    Compiling bevy_derive v0.20.0
[INFO] [stderr]    Compiling profiling-procmacros v1.0.18
[INFO] [stderr]    Compiling bevy_asset_macros v0.20.0
[INFO] [stderr]    Compiling bevy_mod_scripting_derive v0.23.0
[INFO] [stderr]    Compiling variadics_please v1.1.0
[INFO] [stderr]     Checking profiling v1.0.18
[INFO] [stderr]     Checking derive_more v2.1.1
[INFO] [stderr]     Checking bevy_platform v0.20.0
[INFO] [stderr]     Checking naga-types v30.0.1
[INFO] [stderr]     Checking petgraph v0.8.3
[INFO] [stderr]     Checking smol_str v0.2.2
[INFO] [stderr]     Checking ron v0.12.2
[INFO] [stderr]     Checking bevy_utils v0.20.0
[INFO] [stderr]     Checking bevy_tasks v0.20.0
[INFO] [stderr]     Checking wgpu-types v30.0.1
[INFO] [stderr]     Checking bevy_reflect v0.20.0
[INFO] [stderr]     Checking bevy_ecs v0.20.0
[INFO] [stderr]     Checking bevy_app v0.20.0
[INFO] [stderr]     Checking bevy_time v0.20.0
[INFO] [stderr]     Checking bevy_log v0.20.0
[INFO] [stderr]     Checking bevy_mod_scripting_world v0.23.0
[INFO] [stderr]     Checking bevy_system_reflection v0.23.0
[INFO] [stderr]     Checking bevy_diagnostic v0.20.0
[INFO] [stderr]     Checking bevy_asset v0.20.0
[INFO] [stderr]     Checking bevy_mod_scripting_display v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_asset v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_bindings_domain v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_script v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_bindings v0.23.0
[INFO] [stderr]     Checking bevy_mod_scripting_core v0.23.0
[INFO] [stderr]     Checking bevy_reflect_bms_bindings v0.23.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:42:44
[INFO] [stdout]    |
[INFO] [stdout] 42 |                           let output: bool = <::core::ops::RangeFull as ::core::cmp::PartialEq<
[INFO] [stdout]    |  ____________________________________________^
[INFO] [stdout] 43 | |                             ::core::ops::RangeFull,
[INFO] [stdout] 44 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 45 | |                             .into();
[INFO] [stdout]    | |___________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a 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] 44 -                         >>::eq(&_self, &other)
[INFO] [stdout] 45 -                             .into();
[INFO] [stdout] 44 +                         >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 ~                         let output: bool = <bool as Into<_>>::into(<::core::ops::RangeFull as ::core::cmp::PartialEq<
[INFO] [stdout] 43 |                             ::core::ops::RangeFull,
[INFO] [stdout] 44 ~                         >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:84:40
[INFO] [stdout]    |
[INFO] [stdout] 84 |                       let output: bool = <::core::any::TypeId as ::core::cmp::PartialEq<
[INFO] [stdout]    |  ________________________________________^
[INFO] [stdout] 85 | |                         ::core::any::TypeId,
[INFO] [stdout] 86 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 87 | |                     .into();
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 86 -                     >>::eq(&_self, &other)
[INFO] [stdout] 87 -                     .into();
[INFO] [stdout] 86 +                     >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 ~                     let output: bool = <bool as Into<_>>::into(<::core::any::TypeId as ::core::cmp::PartialEq<
[INFO] [stdout] 85 |                         ::core::any::TypeId,
[INFO] [stdout] 86 ~                     >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:110:44
[INFO] [stdout]     |
[INFO] [stdout] 110 |                           let output: bool = ::glam::Quat::abs_diff_eq(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 111 | |                                 _self.into_inner(),
[INFO] [stdout] 112 | |                                 rhs.into_inner(),
[INFO] [stdout] 113 | |                                 max_abs_diff,
[INFO] [stdout] 114 | |                             )
[INFO] [stdout] 115 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 114 -                             )
[INFO] [stdout] 115 -                             .into();
[INFO] [stdout] 114 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::abs_diff_eq(
[INFO] [stdout] 111 |                                 _self.into_inner(),
[INFO] [stdout] 112 |                                 rhs.into_inner(),
[INFO] [stdout] 113 |                                 max_abs_diff,
[INFO] [stdout] 114 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:163:43
[INFO] [stdout]     |
[INFO] [stdout] 163 |                           let output: f32 = ::glam::Quat::angle_between(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 164 | |                                 _self.into_inner(),
[INFO] [stdout] 165 | |                                 rhs.into_inner(),
[INFO] [stdout] 166 | |                             )
[INFO] [stdout] 167 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 166 -                             )
[INFO] [stdout] 167 -                             .into();
[INFO] [stdout] 166 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::angle_between(
[INFO] [stdout] 164 |                                 _self.into_inner(),
[INFO] [stdout] 165 |                                 rhs.into_inner(),
[INFO] [stdout] 166 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:249:43
[INFO] [stdout]     |
[INFO] [stdout] 249 |                           let output: f32 = ::glam::Quat::dot(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 250 | |                                 _self.into_inner(),
[INFO] [stdout] 251 | |                                 rhs.into_inner(),
[INFO] [stdout] 252 | |                             )
[INFO] [stdout] 253 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 252 -                             )
[INFO] [stdout] 253 -                             .into();
[INFO] [stdout] 252 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::dot(
[INFO] [stdout] 250 |                                 _self.into_inner(),
[INFO] [stdout] 251 |                                 rhs.into_inner(),
[INFO] [stdout] 252 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:267:44
[INFO] [stdout]     |
[INFO] [stdout] 267 |                           let output: bool = <::glam::Quat as ::core::cmp::PartialEq<
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 268 | |                             ::glam::Quat,
[INFO] [stdout] 269 | |                         >>::eq(&_self, &rhs)
[INFO] [stdout] 270 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 269 -                         >>::eq(&_self, &rhs)
[INFO] [stdout] 270 -                             .into();
[INFO] [stdout] 269 +                         >>::eq(&_self, &rhs);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 ~                         let output: bool = <bool as Into<_>>::into(<::glam::Quat as ::core::cmp::PartialEq<
[INFO] [stdout] 268 |                             ::glam::Quat,
[INFO] [stdout] 269 ~                         >>::eq(&_self, &rhs));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:601:44
[INFO] [stdout]     |
[INFO] [stdout] 601 |                           let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 602 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 601 -                         let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout] 602 -                             .into();
[INFO] [stdout] 601 +                         let output: bool = ::glam::Quat::is_finite(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 601 -                         let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout] 602 -                             .into();
[INFO] [stdout] 601 +                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_finite(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:616:44
[INFO] [stdout]     |
[INFO] [stdout] 616 |                           let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 617 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                         let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout] 617 -                             .into();
[INFO] [stdout] 616 +                         let output: bool = ::glam::Quat::is_nan(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 616 -                         let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout] 617 -                             .into();
[INFO] [stdout] 616 +                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_nan(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:631:44
[INFO] [stdout]     |
[INFO] [stdout] 631 |                           let output: bool = ::glam::Quat::is_near_identity(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 632 | |                                 _self.into_inner(),
[INFO] [stdout] 633 | |                             )
[INFO] [stdout] 634 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 633 -                             )
[INFO] [stdout] 634 -                             .into();
[INFO] [stdout] 633 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 631 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_near_identity(
[INFO] [stdout] 632 |                                 _self.into_inner(),
[INFO] [stdout] 633 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:648:44
[INFO] [stdout]     |
[INFO] [stdout] 648 |                           let output: bool = ::glam::Quat::is_normalized(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 649 | |                                 _self.into_inner(),
[INFO] [stdout] 650 | |                             )
[INFO] [stdout] 651 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 650 -                             )
[INFO] [stdout] 651 -                             .into();
[INFO] [stdout] 650 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 648 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_normalized(
[INFO] [stdout] 649 |                                 _self.into_inner(),
[INFO] [stdout] 650 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:665:43
[INFO] [stdout]     |
[INFO] [stdout] 665 |                           let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 666 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 665 -                         let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout] 666 -                             .into();
[INFO] [stdout] 665 +                         let output: f32 = ::glam::Quat::length(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 665 -                         let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout] 666 -                             .into();
[INFO] [stdout] 665 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:680:43
[INFO] [stdout]     |
[INFO] [stdout] 680 |                           let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 681 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 680 -                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout] 681 -                             .into();
[INFO] [stdout] 680 +                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 680 -                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout] 681 -                             .into();
[INFO] [stdout] 680 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length_recip(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:695:43
[INFO] [stdout]     |
[INFO] [stdout] 695 |                           let output: f32 = ::glam::Quat::length_squared(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 696 | |                                 _self.into_inner(),
[INFO] [stdout] 697 | |                             )
[INFO] [stdout] 698 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 697 -                             )
[INFO] [stdout] 698 -                             .into();
[INFO] [stdout] 697 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length_squared(
[INFO] [stdout] 696 |                                 _self.into_inner(),
[INFO] [stdout] 697 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[f32; 4]`
[INFO] [stdout]     --> src/lib.rs:1069:48
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1069 -                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout] 1069 +                         let output: [f32; 4] = ::glam::Quat::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1069 -                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout] 1069 +                         let output: [f32; 4] = <[f32; 4] as Into<_>>::into(::glam::Quat::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `(f32, f32, f32)`
[INFO] [stdout]     --> src/lib.rs:1083:55
[INFO] [stdout]      |
[INFO] [stdout] 1083 |                           let output: (f32, f32, f32) = ::glam::Quat::to_euler(
[INFO] [stdout]      |  _______________________________________________________^
[INFO] [stdout] 1084 | |                                 _self.into_inner(),
[INFO] [stdout] 1085 | |                                 order.into_inner(),
[INFO] [stdout] 1086 | |                             )
[INFO] [stdout] 1087 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1086 -                             )
[INFO] [stdout] 1087 -                             .into();
[INFO] [stdout] 1086 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1083 ~                         let output: (f32, f32, f32) = <(f32, f32, f32) as Into<_>>::into(::glam::Quat::to_euler(
[INFO] [stdout] 1084 |                                 _self.into_inner(),
[INFO] [stdout] 1085 |                                 order.into_inner(),
[INFO] [stdout] 1086 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1160:44
[INFO] [stdout]      |
[INFO] [stdout] 1160 |                           let output: bool = ::glam::Vec3::abs_diff_eq(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1161 | |                                 _self.into_inner(),
[INFO] [stdout] 1162 | |                                 rhs.into_inner(),
[INFO] [stdout] 1163 | |                                 max_abs_diff,
[INFO] [stdout] 1164 | |                             )
[INFO] [stdout] 1165 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1164 -                             )
[INFO] [stdout] 1165 -                             .into();
[INFO] [stdout] 1164 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1160 ~                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::abs_diff_eq(
[INFO] [stdout] 1161 |                                 _self.into_inner(),
[INFO] [stdout] 1162 |                                 rhs.into_inner(),
[INFO] [stdout] 1163 |                                 max_abs_diff,
[INFO] [stdout] 1164 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1230:43
[INFO] [stdout]      |
[INFO] [stdout] 1230 |                           let output: f32 = ::glam::Vec3::angle_between(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1231 | |                                 _self.into_inner(),
[INFO] [stdout] 1232 | |                                 rhs.into_inner(),
[INFO] [stdout] 1233 | |                             )
[INFO] [stdout] 1234 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1233 -                             )
[INFO] [stdout] 1234 -                             .into();
[INFO] [stdout] 1233 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1230 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::angle_between(
[INFO] [stdout] 1231 |                                 _self.into_inner(),
[INFO] [stdout] 1232 |                                 rhs.into_inner(),
[INFO] [stdout] 1233 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1248:43
[INFO] [stdout]      |
[INFO] [stdout] 1248 |                           let output: f32 = ::glam::Vec3::angle_to(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1249 | |                                 _self.into_inner(),
[INFO] [stdout] 1250 | |                                 rhs.into_inner(),
[INFO] [stdout] 1251 | |                                 axis.into_inner(),
[INFO] [stdout] 1252 | |                             )
[INFO] [stdout] 1253 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1252 -                             )
[INFO] [stdout] 1253 -                             .into();
[INFO] [stdout] 1252 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1248 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::angle_to(
[INFO] [stdout] 1249 |                                 _self.into_inner(),
[INFO] [stdout] 1250 |                                 rhs.into_inner(),
[INFO] [stdout] 1251 |                                 axis.into_inner(),
[INFO] [stdout] 1252 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1723:43
[INFO] [stdout]      |
[INFO] [stdout] 1723 |                           let output: f32 = ::glam::Vec3::distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1724 | |                                 _self.into_inner(),
[INFO] [stdout] 1725 | |                                 rhs.into_inner(),
[INFO] [stdout] 1726 | |                             )
[INFO] [stdout] 1727 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1726 -                             )
[INFO] [stdout] 1727 -                             .into();
[INFO] [stdout] 1726 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1723 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::distance(
[INFO] [stdout] 1724 |                                 _self.into_inner(),
[INFO] [stdout] 1725 |                                 rhs.into_inner(),
[INFO] [stdout] 1726 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1741:43
[INFO] [stdout]      |
[INFO] [stdout] 1741 |                           let output: f32 = ::glam::Vec3::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1742 | |                                 _self.into_inner(),
[INFO] [stdout] 1743 | |                                 rhs.into_inner(),
[INFO] [stdout] 1744 | |                             )
[INFO] [stdout] 1745 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1744 -                             )
[INFO] [stdout] 1745 -                             .into();
[INFO] [stdout] 1744 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1741 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::distance_squared(
[INFO] [stdout] 1742 |                                 _self.into_inner(),
[INFO] [stdout] 1743 |                                 rhs.into_inner(),
[INFO] [stdout] 1744 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1828:43
[INFO] [stdout]      |
[INFO] [stdout] 1828 |                           let output: f32 = ::glam::Vec3::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1829 | |                                 _self.into_inner(),
[INFO] [stdout] 1830 | |                                 rhs.into_inner(),
[INFO] [stdout] 1831 | |                             )
[INFO] [stdout] 1832 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1831 -                             )
[INFO] [stdout] 1832 -                             .into();
[INFO] [stdout] 1831 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1828 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::dot(
[INFO] [stdout] 1829 |                                 _self.into_inner(),
[INFO] [stdout] 1830 |                                 rhs.into_inner(),
[INFO] [stdout] 1831 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1864:43
[INFO] [stdout]      |
[INFO] [stdout] 1864 |                           let output: f32 = ::glam::Vec3::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1865 | |                                 _self.into_inner(),
[INFO] [stdout] 1866 | |                             )
[INFO] [stdout] 1867 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1866 -                             )
[INFO] [stdout] 1867 -                             .into();
[INFO] [stdout] 1866 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1864 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::element_product(
[INFO] [stdout] 1865 |                                 _self.into_inner(),
[INFO] [stdout] 1866 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1881:43
[INFO] [stdout]      |
[INFO] [stdout] 1881 |                           let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1882 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1881 -                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 1882 -                             .into();
[INFO] [stdout] 1881 +                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1881 -                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 1882 -                             .into();
[INFO] [stdout] 1881 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1896:44
[INFO] [stdout]      |
[INFO] [stdout] 1896 |                           let output: bool = <::glam::Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1897 | |                             ::glam::Vec3,
[INFO] [stdout] 1898 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1899 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1898 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1899 -                             .into();
[INFO] [stdout] 1898 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1896 ~                         let output: bool = <bool as Into<_>>::into(<::glam::Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 1897 |                             ::glam::Vec3,
[INFO] [stdout] 1898 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2047:44
[INFO] [stdout]      |
[INFO] [stdout] 2047 |                           let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2048 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2047 -                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout] 2048 -                             .into();
[INFO] [stdout] 2047 +                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2047 -                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout] 2048 -                             .into();
[INFO] [stdout] 2047 +                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_finite(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2079:44
[INFO] [stdout]      |
[INFO] [stdout] 2079 |                           let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2080 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2079 -                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout] 2080 -                             .into();
[INFO] [stdout] 2079 +                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2079 -                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout] 2080 -                             .into();
[INFO] [stdout] 2079 +                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_nan(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:2111:43
[INFO] [stdout]      |
[INFO] [stdout] 2111 |                           let output: u32 = ::glam::Vec3::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2112 | |                                 _self.into_inner(),
[INFO] [stdout] 2113 | |                             )
[INFO] [stdout] 2114 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2113 -                             )
[INFO] [stdout] 2114 -                             .into();
[INFO] [stdout] 2113 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2111 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::Vec3::is_negative_bitmask(
[INFO] [stdout] 2112 |                                 _self.into_inner(),
[INFO] [stdout] 2113 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2145:44
[INFO] [stdout]      |
[INFO] [stdout] 2145 |                           let output: bool = ::glam::Vec3::is_normalized(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2146 | |                                 _self.into_inner(),
[INFO] [stdout] 2147 | |                             )
[INFO] [stdout] 2148 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2147 -                             )
[INFO] [stdout] 2148 -                             .into();
[INFO] [stdout] 2147 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2145 ~                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_normalized(
[INFO] [stdout] 2146 |                                 _self.into_inner(),
[INFO] [stdout] 2147 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2162:43
[INFO] [stdout]      |
[INFO] [stdout] 2162 |                           let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2163 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2162 -                         let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout] 2163 -                             .into();
[INFO] [stdout] 2162 +                         let output: f32 = ::glam::Vec3::length(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2162 -                         let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout] 2163 -                             .into();
[INFO] [stdout] 2162 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2177:43
[INFO] [stdout]      |
[INFO] [stdout] 2177 |                           let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2178 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2177 -                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout] 2178 -                             .into();
[INFO] [stdout] 2177 +                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2177 -                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout] 2178 -                             .into();
[INFO] [stdout] 2177 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length_recip(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2192:43
[INFO] [stdout]      |
[INFO] [stdout] 2192 |                           let output: f32 = ::glam::Vec3::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2193 | |                                 _self.into_inner(),
[INFO] [stdout] 2194 | |                             )
[INFO] [stdout] 2195 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2194 -                             )
[INFO] [stdout] 2195 -                             .into();
[INFO] [stdout] 2194 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2192 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length_squared(
[INFO] [stdout] 2193 |                                 _self.into_inner(),
[INFO] [stdout] 2194 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2299:43
[INFO] [stdout]      |
[INFO] [stdout] 2299 |                           let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2300 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2299 -                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout] 2300 -                             .into();
[INFO] [stdout] 2299 +                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2299 -                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout] 2300 -                             .into();
[INFO] [stdout] 2299 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:2314:45
[INFO] [stdout]      |
[INFO] [stdout] 2314 |                           let output: usize = ::glam::Vec3::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 2315 | |                                 _self.into_inner(),
[INFO] [stdout] 2316 | |                             )
[INFO] [stdout] 2317 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2316 -                             )
[INFO] [stdout] 2317 -                             .into();
[INFO] [stdout] 2316 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2314 ~                         let output: usize = <usize as Into<_>>::into(::glam::Vec3::max_position(
[INFO] [stdout] 2315 |                                 _self.into_inner(),
[INFO] [stdout] 2316 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2367:43
[INFO] [stdout]      |
[INFO] [stdout] 2367 |                           let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2368 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2367 -                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout] 2368 -                             .into();
[INFO] [stdout] 2367 +                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2367 -                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout] 2368 -                             .into();
[INFO] [stdout] 2367 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:2382:45
[INFO] [stdout]      |
[INFO] [stdout] 2382 |                           let output: usize = ::glam::Vec3::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 2383 | |                                 _self.into_inner(),
[INFO] [stdout] 2384 | |                             )
[INFO] [stdout] 2385 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2384 -                             )
[INFO] [stdout] 2385 -                             .into();
[INFO] [stdout] 2384 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2382 ~                         let output: usize = <usize as Into<_>>::into(::glam::Vec3::min_position(
[INFO] [stdout] 2383 |                                 _self.into_inner(),
[INFO] [stdout] 2384 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[f32; 3]`
[INFO] [stdout]     --> src/lib.rs:3105:48
[INFO] [stdout]      |
[INFO] [stdout] 3105 |                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3105 -                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout] 3105 +                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3105 -                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout] 3105 +                         let output: [f32; 3] = <[f32; 3] as Into<_>>::into(::glam::Vec3::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3265:40
[INFO] [stdout]      |
[INFO] [stdout] 3265 |                       let output: bool = <::bevy_reflect::OffsetAccess as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3266 | |                         ::bevy_reflect::OffsetAccess,
[INFO] [stdout] 3267 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 3268 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3267 -                     >>::eq(&_self, &other)
[INFO] [stdout] 3268 -                     .into();
[INFO] [stdout] 3267 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3265 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_reflect::OffsetAccess as ::core::cmp::PartialEq<
[INFO] [stdout] 3266 |                         ::bevy_reflect::OffsetAccess,
[INFO] [stdout] 3267 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3326:44
[INFO] [stdout]      |
[INFO] [stdout] 3326 |                           let output: bool = <::bevy_reflect::ParsedPath as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3327 | |                             ::bevy_reflect::ParsedPath,
[INFO] [stdout] 3328 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3329 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3328 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3329 -                             .into();
[INFO] [stdout] 3328 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3326 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_reflect::ParsedPath as ::core::cmp::PartialEq<
[INFO] [stdout] 3327 |                             ::bevy_reflect::ParsedPath,
[INFO] [stdout] 3328 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3442:44
[INFO] [stdout]      |
[INFO] [stdout] 3442 |                           let output: bool = <::std::time::Instant as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3443 | |                             ::std::time::Instant,
[INFO] [stdout] 3444 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3445 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3444 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3445 -                             .into();
[INFO] [stdout] 3444 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3442 ~                         let output: bool = <bool as Into<_>>::into(<::std::time::Instant as ::core::cmp::PartialEq<
[INFO] [stdout] 3443 |                             ::std::time::Instant,
[INFO] [stdout] 3444 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3552:44
[INFO] [stdout]      |
[INFO] [stdout] 3552 |                           let output: bool = <::core::net::SocketAddr as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3553 | |                             ::core::net::SocketAddr,
[INFO] [stdout] 3554 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3555 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3554 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3555 -                             .into();
[INFO] [stdout] 3554 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3552 ~                         let output: bool = <bool as Into<_>>::into(<::core::net::SocketAddr as ::core::cmp::PartialEq<
[INFO] [stdout] 3553 |                             ::core::net::SocketAddr,
[INFO] [stdout] 3554 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3569:44
[INFO] [stdout]      |
[INFO] [stdout] 3569 |                           let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3570 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3569 -                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout] 3570 -                             .into();
[INFO] [stdout] 3569 +                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3569 -                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout] 3570 -                             .into();
[INFO] [stdout] 3569 +                         let output: bool = <bool as Into<_>>::into(::core::net::SocketAddr::is_ipv4(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3584:44
[INFO] [stdout]      |
[INFO] [stdout] 3584 |                           let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3585 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3584 -                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout] 3585 -                             .into();
[INFO] [stdout] 3584 +                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3584 -                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout] 3585 -                             .into();
[INFO] [stdout] 3584 +                         let output: bool = <bool as Into<_>>::into(::core::net::SocketAddr::is_ipv6(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/lib.rs:3599:43
[INFO] [stdout]      |
[INFO] [stdout] 3599 |                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3599 -                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout] 3599 +                         let output: u16 = ::core::net::SocketAddr::port(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3599 -                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout] 3599 +                         let output: u16 = <u16 as Into<_>>::into(::core::net::SocketAddr::port(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]     --> src/lib.rs:3613:42
[INFO] [stdout]      |
[INFO] [stdout] 3613 |                           let output: () = ::core::net::SocketAddr::set_port(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 3614 | |                                 &mut _self,
[INFO] [stdout] 3615 | |                                 new_port,
[INFO] [stdout] 3616 | |                             )
[INFO] [stdout] 3617 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3616 -                             )
[INFO] [stdout] 3617 -                             .into();
[INFO] [stdout] 3616 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3613 ~                         let output: () = <() as Into<_>>::into(::core::net::SocketAddr::set_port(
[INFO] [stdout] 3614 |                                 &mut _self,
[INFO] [stdout] 3615 |                                 new_port,
[INFO] [stdout] 3616 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3678:44
[INFO] [stdout]      |
[INFO] [stdout] 3678 |                           let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3679 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3678 -                         let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout] 3679 -                             .into();
[INFO] [stdout] 3678 +                         let output: u128 = ::core::time::Duration::as_micros(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3678 -                         let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout] 3679 -                             .into();
[INFO] [stdout] 3678 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_micros(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3693:44
[INFO] [stdout]      |
[INFO] [stdout] 3693 |                           let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3694 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3693 -                         let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout] 3694 -                             .into();
[INFO] [stdout] 3693 +                         let output: u128 = ::core::time::Duration::as_millis(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3693 -                         let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout] 3694 -                             .into();
[INFO] [stdout] 3693 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_millis(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3708:44
[INFO] [stdout]      |
[INFO] [stdout] 3708 |                           let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3709 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3708 -                         let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout] 3709 -                             .into();
[INFO] [stdout] 3708 +                         let output: u128 = ::core::time::Duration::as_nanos(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3708 -                         let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout] 3709 -                             .into();
[INFO] [stdout] 3708 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_nanos(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/lib.rs:3723:43
[INFO] [stdout]      |
[INFO] [stdout] 3723 |                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3723 -                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout] 3723 +                         let output: u64 = ::core::time::Duration::as_secs(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3723 -                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout] 3723 +                         let output: u64 = <u64 as Into<_>>::into(::core::time::Duration::as_secs(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:3737:43
[INFO] [stdout]      |
[INFO] [stdout] 3737 |                           let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3738 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3737 -                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout] 3738 -                             .into();
[INFO] [stdout] 3737 +                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3737 -                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout] 3738 -                             .into();
[INFO] [stdout] 3737 +                         let output: f32 = <f32 as Into<_>>::into(::core::time::Duration::as_secs_f32(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/lib.rs:3752:43
[INFO] [stdout]      |
[INFO] [stdout] 3752 |                           let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3753 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3752 -                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout] 3753 -                             .into();
[INFO] [stdout] 3752 +                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3752 -                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout] 3753 -                             .into();
[INFO] [stdout] 3752 +                         let output: f64 = <f64 as Into<_>>::into(::core::time::Duration::as_secs_f64(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:3801:43
[INFO] [stdout]      |
[INFO] [stdout] 3801 |                           let output: f32 = ::core::time::Duration::div_duration_f32(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3802 | |                                 _self.into_inner(),
[INFO] [stdout] 3803 | |                                 rhs.into_inner(),
[INFO] [stdout] 3804 | |                             )
[INFO] [stdout] 3805 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3804 -                             )
[INFO] [stdout] 3805 -                             .into();
[INFO] [stdout] 3804 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3801 ~                         let output: f32 = <f32 as Into<_>>::into(::core::time::Duration::div_duration_f32(
[INFO] [stdout] 3802 |                                 _self.into_inner(),
[INFO] [stdout] 3803 |                                 rhs.into_inner(),
[INFO] [stdout] 3804 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/lib.rs:3819:43
[INFO] [stdout]      |
[INFO] [stdout] 3819 |                           let output: f64 = ::core::time::Duration::div_duration_f64(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3820 | |                                 _self.into_inner(),
[INFO] [stdout] 3821 | |                                 rhs.into_inner(),
[INFO] [stdout] 3822 | |                             )
[INFO] [stdout] 3823 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3822 -                             )
[INFO] [stdout] 3823 -                             .into();
[INFO] [stdout] 3822 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3819 ~                         let output: f64 = <f64 as Into<_>>::into(::core::time::Duration::div_duration_f64(
[INFO] [stdout] 3820 |                                 _self.into_inner(),
[INFO] [stdout] 3821 |                                 rhs.into_inner(),
[INFO] [stdout] 3822 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3873:44
[INFO] [stdout]      |
[INFO] [stdout] 3873 |                           let output: bool = <::core::time::Duration as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3874 | |                             ::core::time::Duration,
[INFO] [stdout] 3875 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3876 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3875 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3876 -                             .into();
[INFO] [stdout] 3875 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3873 ~                         let output: bool = <bool as Into<_>>::into(<::core::time::Duration as ::core::cmp::PartialEq<
[INFO] [stdout] 3874 |                             ::core::time::Duration,
[INFO] [stdout] 3875 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4043:44
[INFO] [stdout]      |
[INFO] [stdout] 4043 |                           let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4044 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4043 -                         let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout] 4044 -                             .into();
[INFO] [stdout] 4043 +                         let output: bool = ::core::time::Duration::is_zero(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4043 -                         let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout] 4044 -                             .into();
[INFO] [stdout] 4043 +                         let output: bool = <bool as Into<_>>::into(::core::time::Duration::is_zero(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4200:43
[INFO] [stdout]      |
[INFO] [stdout] 4200 |                           let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4201 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4200 -                         let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout] 4201 -                             .into();
[INFO] [stdout] 4200 +                         let output: u32 = ::core::time::Duration::subsec_micros(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4200 -                         let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout] 4201 -                             .into();
[INFO] [stdout] 4200 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_micros(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4215:43
[INFO] [stdout]      |
[INFO] [stdout] 4215 |                           let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4216 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4215 -                         let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout] 4216 -                             .into();
[INFO] [stdout] 4215 +                         let output: u32 = ::core::time::Duration::subsec_millis(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4215 -                         let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout] 4216 -                             .into();
[INFO] [stdout] 4215 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_millis(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4230:43
[INFO] [stdout]      |
[INFO] [stdout] 4230 |                           let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4231 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4230 -                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout] 4231 -                             .into();
[INFO] [stdout] 4230 +                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4230 -                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout] 4231 -                             .into();
[INFO] [stdout] 4230 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_nanos(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4476:43
[INFO] [stdout]      |
[INFO] [stdout] 4476 |                           let output: u32 = ::glam::IVec2::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4477 | |                                 _self.into_inner(),
[INFO] [stdout] 4478 | |                                 rhs.into_inner(),
[INFO] [stdout] 4479 | |                             )
[INFO] [stdout] 4480 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4479 -                             )
[INFO] [stdout] 4480 -                             .into();
[INFO] [stdout] 4479 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4476 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::chebyshev_distance(
[INFO] [stdout] 4477 |                                 _self.into_inner(),
[INFO] [stdout] 4478 |                                 rhs.into_inner(),
[INFO] [stdout] 4479 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:4494:67
[INFO] [stdout]      |
[INFO] [stdout] 4494 |                           let output: ::core::option::Option<u32> = ::glam::IVec2::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 4495 | |                                 _self.into_inner(),
[INFO] [stdout] 4496 | |                                 rhs.into_inner(),
[INFO] [stdout] 4497 | |                             )
[INFO] [stdout] 4498 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4497 -                             )
[INFO] [stdout] 4498 -                             .into();
[INFO] [stdout] 4497 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4494 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec2::checked_manhattan_distance(
[INFO] [stdout] 4495 |                                 _self.into_inner(),
[INFO] [stdout] 4496 |                                 rhs.into_inner(),
[INFO] [stdout] 4497 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4656:43
[INFO] [stdout]      |
[INFO] [stdout] 4656 |                           let output: i32 = ::glam::IVec2::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4657 | |                                 _self.into_inner(),
[INFO] [stdout] 4658 | |                                 rhs.into_inner(),
[INFO] [stdout] 4659 | |                             )
[INFO] [stdout] 4660 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4659 -                             )
[INFO] [stdout] 4660 -                             .into();
[INFO] [stdout] 4659 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4656 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::distance_squared(
[INFO] [stdout] 4657 |                                 _self.into_inner(),
[INFO] [stdout] 4658 |                                 rhs.into_inner(),
[INFO] [stdout] 4659 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4743:43
[INFO] [stdout]      |
[INFO] [stdout] 4743 |                           let output: i32 = ::glam::IVec2::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4744 | |                                 _self.into_inner(),
[INFO] [stdout] 4745 | |                                 rhs.into_inner(),
[INFO] [stdout] 4746 | |                             )
[INFO] [stdout] 4747 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4746 -                             )
[INFO] [stdout] 4747 -                             .into();
[INFO] [stdout] 4746 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4743 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::dot(
[INFO] [stdout] 4744 |                                 _self.into_inner(),
[INFO] [stdout] 4745 |                                 rhs.into_inner(),
[INFO] [stdout] 4746 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4779:43
[INFO] [stdout]      |
[INFO] [stdout] 4779 |                           let output: i32 = ::glam::IVec2::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4780 | |                                 _self.into_inner(),
[INFO] [stdout] 4781 | |                             )
[INFO] [stdout] 4782 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4781 -                             )
[INFO] [stdout] 4782 -                             .into();
[INFO] [stdout] 4781 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4779 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::element_product(
[INFO] [stdout] 4780 |                                 _self.into_inner(),
[INFO] [stdout] 4781 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4796:43
[INFO] [stdout]      |
[INFO] [stdout] 4796 |                           let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4797 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4796 -                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout] 4797 -                             .into();
[INFO] [stdout] 4796 +                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4796 -                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout] 4797 -                             .into();
[INFO] [stdout] 4796 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4811:44
[INFO] [stdout]      |
[INFO] [stdout] 4811 |                           let output: bool = <::glam::IVec2 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4812 | |                             ::glam::IVec2,
[INFO] [stdout] 4813 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4814 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4813 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4814 -                             .into();
[INFO] [stdout] 4813 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4811 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 4812 |                             ::glam::IVec2,
[INFO] [stdout] 4813 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4861:43
[INFO] [stdout]      |
[INFO] [stdout] 4861 |                           let output: u32 = ::glam::IVec2::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4862 | |                                 _self.into_inner(),
[INFO] [stdout] 4863 | |                             )
[INFO] [stdout] 4864 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4863 -                             )
[INFO] [stdout] 4864 -                             .into();
[INFO] [stdout] 4863 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4861 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::is_negative_bitmask(
[INFO] [stdout] 4862 |                                 _self.into_inner(),
[INFO] [stdout] 4863 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4895:43
[INFO] [stdout]      |
[INFO] [stdout] 4895 |                           let output: i32 = ::glam::IVec2::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4896 | |                                 _self.into_inner(),
[INFO] [stdout] 4897 | |                             )
[INFO] [stdout] 4898 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4897 -                             )
[INFO] [stdout] 4898 -                             .into();
[INFO] [stdout] 4897 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4895 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::length_squared(
[INFO] [stdout] 4896 |                                 _self.into_inner(),
[INFO] [stdout] 4897 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4912:43
[INFO] [stdout]      |
[INFO] [stdout] 4912 |                           let output: u32 = ::glam::IVec2::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4913 | |                                 _self.into_inner(),
[INFO] [stdout] 4914 | |                                 rhs.into_inner(),
[INFO] [stdout] 4915 | |                             )
[INFO] [stdout] 4916 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4915 -                             )
[INFO] [stdout] 4916 -                             .into();
[INFO] [stdout] 4915 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4912 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::manhattan_distance(
[INFO] [stdout] 4913 |                                 _self.into_inner(),
[INFO] [stdout] 4914 |                                 rhs.into_inner(),
[INFO] [stdout] 4915 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4948:43
[INFO] [stdout]      |
[INFO] [stdout] 4948 |                           let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4949 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4948 -                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout] 4949 -                             .into();
[INFO] [stdout] 4948 +                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4948 -                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout] 4949 -                             .into();
[INFO] [stdout] 4948 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:4963:45
[INFO] [stdout]      |
[INFO] [stdout] 4963 |                           let output: usize = ::glam::IVec2::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 4964 | |                                 _self.into_inner(),
[INFO] [stdout] 4965 | |                             )
[INFO] [stdout] 4966 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4965 -                             )
[INFO] [stdout] 4966 -                             .into();
[INFO] [stdout] 4965 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4963 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec2::max_position(
[INFO] [stdout] 4964 |                                 _self.into_inner(),
[INFO] [stdout] 4965 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4998:43
[INFO] [stdout]      |
[INFO] [stdout] 4998 |                           let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4999 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4998 -                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout] 4999 -                             .into();
[INFO] [stdout] 4998 +                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4998 -                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout] 4999 -                             .into();
[INFO] [stdout] 4998 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:5013:45
[INFO] [stdout]      |
[INFO] [stdout] 5013 |                           let output: usize = ::glam::IVec2::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 5014 | |                                 _self.into_inner(),
[INFO] [stdout] 5015 | |                             )
[INFO] [stdout] 5016 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5015 -                             )
[INFO] [stdout] 5016 -                             .into();
[INFO] [stdout] 5015 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5013 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec2::min_position(
[INFO] [stdout] 5014 |                                 _self.into_inner(),
[INFO] [stdout] 5015 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:5129:43
[INFO] [stdout]      |
[INFO] [stdout] 5129 |                           let output: i32 = ::glam::IVec2::perp_dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 5130 | |                                 _self.into_inner(),
[INFO] [stdout] 5131 | |                                 rhs.into_inner(),
[INFO] [stdout] 5132 | |                             )
[INFO] [stdout] 5133 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5132 -                             )
[INFO] [stdout] 5133 -                             .into();
[INFO] [stdout] 5132 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5129 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::perp_dot(
[INFO] [stdout] 5130 |                                 _self.into_inner(),
[INFO] [stdout] 5131 |                                 rhs.into_inner(),
[INFO] [stdout] 5132 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 2]`
[INFO] [stdout]     --> src/lib.rs:5447:48
[INFO] [stdout]      |
[INFO] [stdout] 5447 |                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5447 -                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout] 5447 +                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5447 -                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout] 5447 +                         let output: [i32; 2] = <[i32; 2] as Into<_>>::into(::glam::IVec2::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:5851:43
[INFO] [stdout]      |
[INFO] [stdout] 5851 |                           let output: u32 = ::glam::IVec3::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 5852 | |                                 _self.into_inner(),
[INFO] [stdout] 5853 | |                                 rhs.into_inner(),
[INFO] [stdout] 5854 | |                             )
[INFO] [stdout] 5855 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5854 -                             )
[INFO] [stdout] 5855 -                             .into();
[INFO] [stdout] 5854 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5851 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::chebyshev_distance(
[INFO] [stdout] 5852 |                                 _self.into_inner(),
[INFO] [stdout] 5853 |                                 rhs.into_inner(),
[INFO] [stdout] 5854 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:5869:67
[INFO] [stdout]      |
[INFO] [stdout] 5869 |                           let output: ::core::option::Option<u32> = ::glam::IVec3::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 5870 | |                                 _self.into_inner(),
[INFO] [stdout] 5871 | |                                 rhs.into_inner(),
[INFO] [stdout] 5872 | |                             )
[INFO] [stdout] 5873 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5872 -                             )
[INFO] [stdout] 5873 -                             .into();
[INFO] [stdout] 5872 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5869 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec3::checked_manhattan_distance(
[INFO] [stdout] 5870 |                                 _self.into_inner(),
[INFO] [stdout] 5871 |                                 rhs.into_inner(),
[INFO] [stdout] 5872 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6049:43
[INFO] [stdout]      |
[INFO] [stdout] 6049 |                           let output: i32 = ::glam::IVec3::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6050 | |                                 _self.into_inner(),
[INFO] [stdout] 6051 | |                                 rhs.into_inner(),
[INFO] [stdout] 6052 | |                             )
[INFO] [stdout] 6053 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6052 -                             )
[INFO] [stdout] 6053 -                             .into();
[INFO] [stdout] 6052 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6049 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::distance_squared(
[INFO] [stdout] 6050 |                                 _self.into_inner(),
[INFO] [stdout] 6051 |                                 rhs.into_inner(),
[INFO] [stdout] 6052 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6136:43
[INFO] [stdout]      |
[INFO] [stdout] 6136 |                           let output: i32 = ::glam::IVec3::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6137 | |                                 _self.into_inner(),
[INFO] [stdout] 6138 | |                                 rhs.into_inner(),
[INFO] [stdout] 6139 | |                             )
[INFO] [stdout] 6140 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6139 -                             )
[INFO] [stdout] 6140 -                             .into();
[INFO] [stdout] 6139 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6136 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::dot(
[INFO] [stdout] 6137 |                                 _self.into_inner(),
[INFO] [stdout] 6138 |                                 rhs.into_inner(),
[INFO] [stdout] 6139 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6172:43
[INFO] [stdout]      |
[INFO] [stdout] 6172 |                           let output: i32 = ::glam::IVec3::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6173 | |                                 _self.into_inner(),
[INFO] [stdout] 6174 | |                             )
[INFO] [stdout] 6175 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6174 -                             )
[INFO] [stdout] 6175 -                             .into();
[INFO] [stdout] 6174 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6172 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::element_product(
[INFO] [stdout] 6173 |                                 _self.into_inner(),
[INFO] [stdout] 6174 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6189:43
[INFO] [stdout]      |
[INFO] [stdout] 6189 |                           let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6190 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6189 -                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout] 6190 -                             .into();
[INFO] [stdout] 6189 +                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6189 -                         let output: i32 = ::glam::IVec3::element_sum(_self.into_inner())
[INFO] [stdout] 6190 -                             .into();
[INFO] [stdout] 6189 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:6204:44
[INFO] [stdout]      |
[INFO] [stdout] 6204 |                           let output: bool = <::glam::IVec3 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 6205 | |                             ::glam::IVec3,
[INFO] [stdout] 6206 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 6207 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6206 -                         >>::eq(&_self, &other)
[INFO] [stdout] 6207 -                             .into();
[INFO] [stdout] 6206 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6204 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 6205 |                             ::glam::IVec3,
[INFO] [stdout] 6206 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:6254:43
[INFO] [stdout]      |
[INFO] [stdout] 6254 |                           let output: u32 = ::glam::IVec3::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6255 | |                                 _self.into_inner(),
[INFO] [stdout] 6256 | |                             )
[INFO] [stdout] 6257 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6256 -                             )
[INFO] [stdout] 6257 -                             .into();
[INFO] [stdout] 6256 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6254 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::is_negative_bitmask(
[INFO] [stdout] 6255 |                                 _self.into_inner(),
[INFO] [stdout] 6256 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6288:43
[INFO] [stdout]      |
[INFO] [stdout] 6288 |                           let output: i32 = ::glam::IVec3::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6289 | |                                 _self.into_inner(),
[INFO] [stdout] 6290 | |                             )
[INFO] [stdout] 6291 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6290 -                             )
[INFO] [stdout] 6291 -                             .into();
[INFO] [stdout] 6290 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6288 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::length_squared(
[INFO] [stdout] 6289 |                                 _self.into_inner(),
[INFO] [stdout] 6290 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:6305:43
[INFO] [stdout]      |
[INFO] [stdout] 6305 |                           let output: u32 = ::glam::IVec3::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6306 | |                                 _self.into_inner(),
[INFO] [stdout] 6307 | |                                 rhs.into_inner(),
[INFO] [stdout] 6308 | |                             )
[INFO] [stdout] 6309 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6308 -                             )
[INFO] [stdout] 6309 -                             .into();
[INFO] [stdout] 6308 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6305 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec3::manhattan_distance(
[INFO] [stdout] 6306 |                                 _self.into_inner(),
[INFO] [stdout] 6307 |                                 rhs.into_inner(),
[INFO] [stdout] 6308 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6341:43
[INFO] [stdout]      |
[INFO] [stdout] 6341 |                           let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6342 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6341 -                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout] 6342 -                             .into();
[INFO] [stdout] 6341 +                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6341 -                         let output: i32 = ::glam::IVec3::max_element(_self.into_inner())
[INFO] [stdout] 6342 -                             .into();
[INFO] [stdout] 6341 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:6356:45
[INFO] [stdout]      |
[INFO] [stdout] 6356 |                           let output: usize = ::glam::IVec3::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 6357 | |                                 _self.into_inner(),
[INFO] [stdout] 6358 | |                             )
[INFO] [stdout] 6359 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6358 -                             )
[INFO] [stdout] 6359 -                             .into();
[INFO] [stdout] 6358 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6356 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec3::max_position(
[INFO] [stdout] 6357 |                                 _self.into_inner(),
[INFO] [stdout] 6358 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:6391:43
[INFO] [stdout]      |
[INFO] [stdout] 6391 |                           let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 6392 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6391 -                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout] 6392 -                             .into();
[INFO] [stdout] 6391 +                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6391 -                         let output: i32 = ::glam::IVec3::min_element(_self.into_inner())
[INFO] [stdout] 6392 -                             .into();
[INFO] [stdout] 6391 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec3::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:6406:45
[INFO] [stdout]      |
[INFO] [stdout] 6406 |                           let output: usize = ::glam::IVec3::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 6407 | |                                 _self.into_inner(),
[INFO] [stdout] 6408 | |                             )
[INFO] [stdout] 6409 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6408 -                             )
[INFO] [stdout] 6409 -                             .into();
[INFO] [stdout] 6408 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6406 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec3::min_position(
[INFO] [stdout] 6407 |                                 _self.into_inner(),
[INFO] [stdout] 6408 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 3]`
[INFO] [stdout]     --> src/lib.rs:6788:48
[INFO] [stdout]      |
[INFO] [stdout] 6788 |                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 6788 -                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout] 6788 +                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 6788 -                         let output: [i32; 3] = ::glam::IVec3::to_array(&_self).into();
[INFO] [stdout] 6788 +                         let output: [i32; 3] = <[i32; 3] as Into<_>>::into(::glam::IVec3::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7210:43
[INFO] [stdout]      |
[INFO] [stdout] 7210 |                           let output: u32 = ::glam::IVec4::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7211 | |                                 _self.into_inner(),
[INFO] [stdout] 7212 | |                                 rhs.into_inner(),
[INFO] [stdout] 7213 | |                             )
[INFO] [stdout] 7214 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7213 -                             )
[INFO] [stdout] 7214 -                             .into();
[INFO] [stdout] 7213 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7210 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::chebyshev_distance(
[INFO] [stdout] 7211 |                                 _self.into_inner(),
[INFO] [stdout] 7212 |                                 rhs.into_inner(),
[INFO] [stdout] 7213 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:7228:67
[INFO] [stdout]      |
[INFO] [stdout] 7228 |                           let output: ::core::option::Option<u32> = ::glam::IVec4::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 7229 | |                                 _self.into_inner(),
[INFO] [stdout] 7230 | |                                 rhs.into_inner(),
[INFO] [stdout] 7231 | |                             )
[INFO] [stdout] 7232 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7231 -                             )
[INFO] [stdout] 7232 -                             .into();
[INFO] [stdout] 7231 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7228 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec4::checked_manhattan_distance(
[INFO] [stdout] 7229 |                                 _self.into_inner(),
[INFO] [stdout] 7230 |                                 rhs.into_inner(),
[INFO] [stdout] 7231 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7390:43
[INFO] [stdout]      |
[INFO] [stdout] 7390 |                           let output: i32 = ::glam::IVec4::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7391 | |                                 _self.into_inner(),
[INFO] [stdout] 7392 | |                                 rhs.into_inner(),
[INFO] [stdout] 7393 | |                             )
[INFO] [stdout] 7394 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7393 -                             )
[INFO] [stdout] 7394 -                             .into();
[INFO] [stdout] 7393 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7390 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::distance_squared(
[INFO] [stdout] 7391 |                                 _self.into_inner(),
[INFO] [stdout] 7392 |                                 rhs.into_inner(),
[INFO] [stdout] 7393 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7477:43
[INFO] [stdout]      |
[INFO] [stdout] 7477 |                           let output: i32 = ::glam::IVec4::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7478 | |                                 _self.into_inner(),
[INFO] [stdout] 7479 | |                                 rhs.into_inner(),
[INFO] [stdout] 7480 | |                             )
[INFO] [stdout] 7481 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7480 -                             )
[INFO] [stdout] 7481 -                             .into();
[INFO] [stdout] 7480 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7477 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::dot(
[INFO] [stdout] 7478 |                                 _self.into_inner(),
[INFO] [stdout] 7479 |                                 rhs.into_inner(),
[INFO] [stdout] 7480 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7513:43
[INFO] [stdout]      |
[INFO] [stdout] 7513 |                           let output: i32 = ::glam::IVec4::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7514 | |                                 _self.into_inner(),
[INFO] [stdout] 7515 | |                             )
[INFO] [stdout] 7516 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7515 -                             )
[INFO] [stdout] 7516 -                             .into();
[INFO] [stdout] 7515 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7513 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::element_product(
[INFO] [stdout] 7514 |                                 _self.into_inner(),
[INFO] [stdout] 7515 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7530:43
[INFO] [stdout]      |
[INFO] [stdout] 7530 |                           let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7531 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7530 -                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout] 7531 -                             .into();
[INFO] [stdout] 7530 +                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7530 -                         let output: i32 = ::glam::IVec4::element_sum(_self.into_inner())
[INFO] [stdout] 7531 -                             .into();
[INFO] [stdout] 7530 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:7545:44
[INFO] [stdout]      |
[INFO] [stdout] 7545 |                           let output: bool = <::glam::IVec4 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 7546 | |                             ::glam::IVec4,
[INFO] [stdout] 7547 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 7548 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7547 -                         >>::eq(&_self, &other)
[INFO] [stdout] 7548 -                             .into();
[INFO] [stdout] 7547 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7545 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 7546 |                             ::glam::IVec4,
[INFO] [stdout] 7547 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7577:43
[INFO] [stdout]      |
[INFO] [stdout] 7577 |                           let output: u32 = ::glam::IVec4::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7578 | |                                 _self.into_inner(),
[INFO] [stdout] 7579 | |                             )
[INFO] [stdout] 7580 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7579 -                             )
[INFO] [stdout] 7580 -                             .into();
[INFO] [stdout] 7579 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7577 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::is_negative_bitmask(
[INFO] [stdout] 7578 |                                 _self.into_inner(),
[INFO] [stdout] 7579 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7611:43
[INFO] [stdout]      |
[INFO] [stdout] 7611 |                           let output: i32 = ::glam::IVec4::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7612 | |                                 _self.into_inner(),
[INFO] [stdout] 7613 | |                             )
[INFO] [stdout] 7614 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7613 -                             )
[INFO] [stdout] 7614 -                             .into();
[INFO] [stdout] 7613 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7611 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::length_squared(
[INFO] [stdout] 7612 |                                 _self.into_inner(),
[INFO] [stdout] 7613 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:7628:43
[INFO] [stdout]      |
[INFO] [stdout] 7628 |                           let output: u32 = ::glam::IVec4::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7629 | |                                 _self.into_inner(),
[INFO] [stdout] 7630 | |                                 rhs.into_inner(),
[INFO] [stdout] 7631 | |                             )
[INFO] [stdout] 7632 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7631 -                             )
[INFO] [stdout] 7632 -                             .into();
[INFO] [stdout] 7631 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7628 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec4::manhattan_distance(
[INFO] [stdout] 7629 |                                 _self.into_inner(),
[INFO] [stdout] 7630 |                                 rhs.into_inner(),
[INFO] [stdout] 7631 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7664:43
[INFO] [stdout]      |
[INFO] [stdout] 7664 |                           let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7665 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7664 -                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout] 7665 -                             .into();
[INFO] [stdout] 7664 +                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7664 -                         let output: i32 = ::glam::IVec4::max_element(_self.into_inner())
[INFO] [stdout] 7665 -                             .into();
[INFO] [stdout] 7664 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:7679:45
[INFO] [stdout]      |
[INFO] [stdout] 7679 |                           let output: usize = ::glam::IVec4::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 7680 | |                                 _self.into_inner(),
[INFO] [stdout] 7681 | |                             )
[INFO] [stdout] 7682 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7681 -                             )
[INFO] [stdout] 7682 -                             .into();
[INFO] [stdout] 7681 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7679 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec4::max_position(
[INFO] [stdout] 7680 |                                 _self.into_inner(),
[INFO] [stdout] 7681 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:7714:43
[INFO] [stdout]      |
[INFO] [stdout] 7714 |                           let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 7715 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7714 -                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout] 7715 -                             .into();
[INFO] [stdout] 7714 +                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7714 -                         let output: i32 = ::glam::IVec4::min_element(_self.into_inner())
[INFO] [stdout] 7715 -                             .into();
[INFO] [stdout] 7714 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec4::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:7729:45
[INFO] [stdout]      |
[INFO] [stdout] 7729 |                           let output: usize = ::glam::IVec4::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 7730 | |                                 _self.into_inner(),
[INFO] [stdout] 7731 | |                             )
[INFO] [stdout] 7732 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7731 -                             )
[INFO] [stdout] 7732 -                             .into();
[INFO] [stdout] 7731 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7729 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec4::min_position(
[INFO] [stdout] 7730 |                                 _self.into_inner(),
[INFO] [stdout] 7731 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 4]`
[INFO] [stdout]     --> src/lib.rs:8111:48
[INFO] [stdout]      |
[INFO] [stdout] 8111 |                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8111 -                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout] 8111 +                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8111 -                         let output: [i32; 4] = ::glam::IVec4::to_array(&_self).into();
[INFO] [stdout] 8111 +                         let output: [i32; 4] = <[i32; 4] as Into<_>>::into(::glam::IVec4::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:8551:42
[INFO] [stdout]      |
[INFO] [stdout] 8551 |                           let output: u8 = ::glam::I8Vec2::chebyshev_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8552 | |                                 _self.into_inner(),
[INFO] [stdout] 8553 | |                                 rhs.into_inner(),
[INFO] [stdout] 8554 | |                             )
[INFO] [stdout] 8555 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8554 -                             )
[INFO] [stdout] 8555 -                             .into();
[INFO] [stdout] 8554 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8551 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec2::chebyshev_distance(
[INFO] [stdout] 8552 |                                 _self.into_inner(),
[INFO] [stdout] 8553 |                                 rhs.into_inner(),
[INFO] [stdout] 8554 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]     --> src/lib.rs:8569:66
[INFO] [stdout]      |
[INFO] [stdout] 8569 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec2::checked_manhattan_distance(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 8570 | |                                 _self.into_inner(),
[INFO] [stdout] 8571 | |                                 rhs.into_inner(),
[INFO] [stdout] 8572 | |                             )
[INFO] [stdout] 8573 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8572 -                             )
[INFO] [stdout] 8573 -                             .into();
[INFO] [stdout] 8572 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8569 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec2::checked_manhattan_distance(
[INFO] [stdout] 8570 |                                 _self.into_inner(),
[INFO] [stdout] 8571 |                                 rhs.into_inner(),
[INFO] [stdout] 8572 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8731:42
[INFO] [stdout]      |
[INFO] [stdout] 8731 |                           let output: i8 = ::glam::I8Vec2::distance_squared(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8732 | |                                 _self.into_inner(),
[INFO] [stdout] 8733 | |                                 rhs.into_inner(),
[INFO] [stdout] 8734 | |                             )
[INFO] [stdout] 8735 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8734 -                             )
[INFO] [stdout] 8735 -                             .into();
[INFO] [stdout] 8734 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8731 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::distance_squared(
[INFO] [stdout] 8732 |                                 _self.into_inner(),
[INFO] [stdout] 8733 |                                 rhs.into_inner(),
[INFO] [stdout] 8734 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8818:42
[INFO] [stdout]      |
[INFO] [stdout] 8818 |                           let output: i8 = ::glam::I8Vec2::dot(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8819 | |                                 _self.into_inner(),
[INFO] [stdout] 8820 | |                                 rhs.into_inner(),
[INFO] [stdout] 8821 | |                             )
[INFO] [stdout] 8822 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8821 -                             )
[INFO] [stdout] 8822 -                             .into();
[INFO] [stdout] 8821 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8818 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::dot(
[INFO] [stdout] 8819 |                                 _self.into_inner(),
[INFO] [stdout] 8820 |                                 rhs.into_inner(),
[INFO] [stdout] 8821 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8854:42
[INFO] [stdout]      |
[INFO] [stdout] 8854 |                           let output: i8 = ::glam::I8Vec2::element_product(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8855 | |                                 _self.into_inner(),
[INFO] [stdout] 8856 | |                             )
[INFO] [stdout] 8857 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8856 -                             )
[INFO] [stdout] 8857 -                             .into();
[INFO] [stdout] 8856 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8854 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::element_product(
[INFO] [stdout] 8855 |                                 _self.into_inner(),
[INFO] [stdout] 8856 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8871:42
[INFO] [stdout]      |
[INFO] [stdout] 8871 |                           let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8872 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8871 -                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout] 8872 -                             .into();
[INFO] [stdout] 8871 +                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8871 -                         let output: i8 = ::glam::I8Vec2::element_sum(_self.into_inner())
[INFO] [stdout] 8872 -                             .into();
[INFO] [stdout] 8871 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:8886:44
[INFO] [stdout]      |
[INFO] [stdout] 8886 |                           let output: bool = <::glam::I8Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 8887 | |                             ::glam::I8Vec2,
[INFO] [stdout] 8888 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 8889 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8888 -                         >>::eq(&_self, &other)
[INFO] [stdout] 8889 -                             .into();
[INFO] [stdout] 8888 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8886 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 8887 |                             ::glam::I8Vec2,
[INFO] [stdout] 8888 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:8936:43
[INFO] [stdout]      |
[INFO] [stdout] 8936 |                           let output: u32 = ::glam::I8Vec2::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 8937 | |                                 _self.into_inner(),
[INFO] [stdout] 8938 | |                             )
[INFO] [stdout] 8939 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8938 -                             )
[INFO] [stdout] 8939 -                             .into();
[INFO] [stdout] 8938 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8936 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec2::is_negative_bitmask(
[INFO] [stdout] 8937 |                                 _self.into_inner(),
[INFO] [stdout] 8938 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:8970:42
[INFO] [stdout]      |
[INFO] [stdout] 8970 |                           let output: i8 = ::glam::I8Vec2::length_squared(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8971 | |                                 _self.into_inner(),
[INFO] [stdout] 8972 | |                             )
[INFO] [stdout] 8973 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8972 -                             )
[INFO] [stdout] 8973 -                             .into();
[INFO] [stdout] 8972 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8970 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::length_squared(
[INFO] [stdout] 8971 |                                 _self.into_inner(),
[INFO] [stdout] 8972 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:8987:42
[INFO] [stdout]      |
[INFO] [stdout] 8987 |                           let output: u8 = ::glam::I8Vec2::manhattan_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 8988 | |                                 _self.into_inner(),
[INFO] [stdout] 8989 | |                                 rhs.into_inner(),
[INFO] [stdout] 8990 | |                             )
[INFO] [stdout] 8991 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8990 -                             )
[INFO] [stdout] 8991 -                             .into();
[INFO] [stdout] 8990 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8987 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec2::manhattan_distance(
[INFO] [stdout] 8988 |                                 _self.into_inner(),
[INFO] [stdout] 8989 |                                 rhs.into_inner(),
[INFO] [stdout] 8990 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9023:42
[INFO] [stdout]      |
[INFO] [stdout] 9023 |                           let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9024 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9023 -                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout] 9024 -                             .into();
[INFO] [stdout] 9023 +                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9023 -                         let output: i8 = ::glam::I8Vec2::max_element(_self.into_inner())
[INFO] [stdout] 9024 -                             .into();
[INFO] [stdout] 9023 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:9038:45
[INFO] [stdout]      |
[INFO] [stdout] 9038 |                           let output: usize = ::glam::I8Vec2::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 9039 | |                                 _self.into_inner(),
[INFO] [stdout] 9040 | |                             )
[INFO] [stdout] 9041 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9040 -                             )
[INFO] [stdout] 9041 -                             .into();
[INFO] [stdout] 9040 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9038 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec2::max_position(
[INFO] [stdout] 9039 |                                 _self.into_inner(),
[INFO] [stdout] 9040 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9073:42
[INFO] [stdout]      |
[INFO] [stdout] 9073 |                           let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9074 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9073 -                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout] 9074 -                             .into();
[INFO] [stdout] 9073 +                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9073 -                         let output: i8 = ::glam::I8Vec2::min_element(_self.into_inner())
[INFO] [stdout] 9074 -                             .into();
[INFO] [stdout] 9073 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:9088:45
[INFO] [stdout]      |
[INFO] [stdout] 9088 |                           let output: usize = ::glam::I8Vec2::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 9089 | |                                 _self.into_inner(),
[INFO] [stdout] 9090 | |                             )
[INFO] [stdout] 9091 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9090 -                             )
[INFO] [stdout] 9091 -                             .into();
[INFO] [stdout] 9090 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9088 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec2::min_position(
[INFO] [stdout] 9089 |                                 _self.into_inner(),
[INFO] [stdout] 9090 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]     --> src/lib.rs:9204:42
[INFO] [stdout]      |
[INFO] [stdout] 9204 |                           let output: i8 = ::glam::I8Vec2::perp_dot(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9205 | |                                 _self.into_inner(),
[INFO] [stdout] 9206 | |                                 rhs.into_inner(),
[INFO] [stdout] 9207 | |                             )
[INFO] [stdout] 9208 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9207 -                             )
[INFO] [stdout] 9208 -                             .into();
[INFO] [stdout] 9207 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9204 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec2::perp_dot(
[INFO] [stdout] 9205 |                                 _self.into_inner(),
[INFO] [stdout] 9206 |                                 rhs.into_inner(),
[INFO] [stdout] 9207 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 2]`
[INFO] [stdout]     --> src/lib.rs:9522:47
[INFO] [stdout]      |
[INFO] [stdout] 9522 |                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9522 -                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout] 9522 +                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9522 -                         let output: [i8; 2] = ::glam::I8Vec2::to_array(&_self).into();
[INFO] [stdout] 9522 +                         let output: [i8; 2] = <[i8; 2] as Into<_>>::into(::glam::I8Vec2::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/lib.rs:9926:42
[INFO] [stdout]      |
[INFO] [stdout] 9926 |                           let output: u8 = ::glam::I8Vec3::chebyshev_distance(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 9927 | |                                 _self.into_inner(),
[INFO] [stdout] 9928 | |                                 rhs.into_inner(),
[INFO] [stdout] 9929 | |                             )
[INFO] [stdout] 9930 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9929 -                             )
[INFO] [stdout] 9930 -                             .into();
[INFO] [stdout] 9929 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9926 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec3::chebyshev_distance(
[INFO] [stdout] 9927 |                                 _self.into_inner(),
[INFO] [stdout] 9928 |                                 rhs.into_inner(),
[INFO] [stdout] 9929 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]     --> src/lib.rs:9944:66
[INFO] [stdout]      |
[INFO] [stdout] 9944 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec3::checked_manhattan_distance(
[INFO] [stdout]      |  __________________________________________________________________^
[INFO] [stdout] 9945 | |                                 _self.into_inner(),
[INFO] [stdout] 9946 | |                                 rhs.into_inner(),
[INFO] [stdout] 9947 | |                             )
[INFO] [stdout] 9948 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9947 -                             )
[INFO] [stdout] 9948 -                             .into();
[INFO] [stdout] 9947 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9944 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec3::checked_manhattan_distance(
[INFO] [stdout] 9945 |                                 _self.into_inner(),
[INFO] [stdout] 9946 |                                 rhs.into_inner(),
[INFO] [stdout] 9947 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10124:42
[INFO] [stdout]       |
[INFO] [stdout] 10124 |                           let output: i8 = ::glam::I8Vec3::distance_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10125 | |                                 _self.into_inner(),
[INFO] [stdout] 10126 | |                                 rhs.into_inner(),
[INFO] [stdout] 10127 | |                             )
[INFO] [stdout] 10128 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10127 -                             )
[INFO] [stdout] 10128 -                             .into();
[INFO] [stdout] 10127 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10124 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::distance_squared(
[INFO] [stdout] 10125 |                                 _self.into_inner(),
[INFO] [stdout] 10126 |                                 rhs.into_inner(),
[INFO] [stdout] 10127 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10211:42
[INFO] [stdout]       |
[INFO] [stdout] 10211 |                           let output: i8 = ::glam::I8Vec3::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10212 | |                                 _self.into_inner(),
[INFO] [stdout] 10213 | |                                 rhs.into_inner(),
[INFO] [stdout] 10214 | |                             )
[INFO] [stdout] 10215 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10214 -                             )
[INFO] [stdout] 10215 -                             .into();
[INFO] [stdout] 10214 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10211 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::dot(
[INFO] [stdout] 10212 |                                 _self.into_inner(),
[INFO] [stdout] 10213 |                                 rhs.into_inner(),
[INFO] [stdout] 10214 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10247:42
[INFO] [stdout]       |
[INFO] [stdout] 10247 |                           let output: i8 = ::glam::I8Vec3::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10248 | |                                 _self.into_inner(),
[INFO] [stdout] 10249 | |                             )
[INFO] [stdout] 10250 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10249 -                             )
[INFO] [stdout] 10250 -                             .into();
[INFO] [stdout] 10249 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10247 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::element_product(
[INFO] [stdout] 10248 |                                 _self.into_inner(),
[INFO] [stdout] 10249 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10264:42
[INFO] [stdout]       |
[INFO] [stdout] 10264 |                           let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10265 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10264 -                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 10265 -                             .into();
[INFO] [stdout] 10264 +                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10264 -                         let output: i8 = ::glam::I8Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 10265 -                             .into();
[INFO] [stdout] 10264 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:10279:44
[INFO] [stdout]       |
[INFO] [stdout] 10279 |                           let output: bool = <::glam::I8Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 10280 | |                             ::glam::I8Vec3,
[INFO] [stdout] 10281 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 10282 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10281 -                         >>::eq(&_self, &other)
[INFO] [stdout] 10282 -                             .into();
[INFO] [stdout] 10281 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10279 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 10280 |                             ::glam::I8Vec3,
[INFO] [stdout] 10281 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:10329:43
[INFO] [stdout]       |
[INFO] [stdout] 10329 |                           let output: u32 = ::glam::I8Vec3::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 10330 | |                                 _self.into_inner(),
[INFO] [stdout] 10331 | |                             )
[INFO] [stdout] 10332 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10331 -                             )
[INFO] [stdout] 10332 -                             .into();
[INFO] [stdout] 10331 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10329 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec3::is_negative_bitmask(
[INFO] [stdout] 10330 |                                 _self.into_inner(),
[INFO] [stdout] 10331 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10363:42
[INFO] [stdout]       |
[INFO] [stdout] 10363 |                           let output: i8 = ::glam::I8Vec3::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10364 | |                                 _self.into_inner(),
[INFO] [stdout] 10365 | |                             )
[INFO] [stdout] 10366 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10365 -                             )
[INFO] [stdout] 10366 -                             .into();
[INFO] [stdout] 10365 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10363 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::length_squared(
[INFO] [stdout] 10364 |                                 _self.into_inner(),
[INFO] [stdout] 10365 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:10380:42
[INFO] [stdout]       |
[INFO] [stdout] 10380 |                           let output: u8 = ::glam::I8Vec3::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10381 | |                                 _self.into_inner(),
[INFO] [stdout] 10382 | |                                 rhs.into_inner(),
[INFO] [stdout] 10383 | |                             )
[INFO] [stdout] 10384 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10383 -                             )
[INFO] [stdout] 10384 -                             .into();
[INFO] [stdout] 10383 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10380 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec3::manhattan_distance(
[INFO] [stdout] 10381 |                                 _self.into_inner(),
[INFO] [stdout] 10382 |                                 rhs.into_inner(),
[INFO] [stdout] 10383 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10416:42
[INFO] [stdout]       |
[INFO] [stdout] 10416 |                           let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10417 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10416 -                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout] 10417 -                             .into();
[INFO] [stdout] 10416 +                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10416 -                         let output: i8 = ::glam::I8Vec3::max_element(_self.into_inner())
[INFO] [stdout] 10417 -                             .into();
[INFO] [stdout] 10416 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:10431:45
[INFO] [stdout]       |
[INFO] [stdout] 10431 |                           let output: usize = ::glam::I8Vec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 10432 | |                                 _self.into_inner(),
[INFO] [stdout] 10433 | |                             )
[INFO] [stdout] 10434 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10433 -                             )
[INFO] [stdout] 10434 -                             .into();
[INFO] [stdout] 10433 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10431 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec3::max_position(
[INFO] [stdout] 10432 |                                 _self.into_inner(),
[INFO] [stdout] 10433 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:10466:42
[INFO] [stdout]       |
[INFO] [stdout] 10466 |                           let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 10467 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10466 -                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout] 10467 -                             .into();
[INFO] [stdout] 10466 +                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10466 -                         let output: i8 = ::glam::I8Vec3::min_element(_self.into_inner())
[INFO] [stdout] 10467 -                             .into();
[INFO] [stdout] 10466 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec3::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:10481:45
[INFO] [stdout]       |
[INFO] [stdout] 10481 |                           let output: usize = ::glam::I8Vec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 10482 | |                                 _self.into_inner(),
[INFO] [stdout] 10483 | |                             )
[INFO] [stdout] 10484 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10483 -                             )
[INFO] [stdout] 10484 -                             .into();
[INFO] [stdout] 10483 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10481 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec3::min_position(
[INFO] [stdout] 10482 |                                 _self.into_inner(),
[INFO] [stdout] 10483 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 3]`
[INFO] [stdout]      --> src/lib.rs:10863:47
[INFO] [stdout]       |
[INFO] [stdout] 10863 |                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10863 -                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout] 10863 +                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10863 -                         let output: [i8; 3] = ::glam::I8Vec3::to_array(&_self).into();
[INFO] [stdout] 10863 +                         let output: [i8; 3] = <[i8; 3] as Into<_>>::into(::glam::I8Vec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:11285:42
[INFO] [stdout]       |
[INFO] [stdout] 11285 |                           let output: u8 = ::glam::I8Vec4::chebyshev_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11286 | |                                 _self.into_inner(),
[INFO] [stdout] 11287 | |                                 rhs.into_inner(),
[INFO] [stdout] 11288 | |                             )
[INFO] [stdout] 11289 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11288 -                             )
[INFO] [stdout] 11289 -                             .into();
[INFO] [stdout] 11288 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11285 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec4::chebyshev_distance(
[INFO] [stdout] 11286 |                                 _self.into_inner(),
[INFO] [stdout] 11287 |                                 rhs.into_inner(),
[INFO] [stdout] 11288 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]      --> src/lib.rs:11303:66
[INFO] [stdout]       |
[INFO] [stdout] 11303 |                           let output: ::core::option::Option<u8> = ::glam::I8Vec4::checked_manhattan_distance(
[INFO] [stdout]       |  __________________________________________________________________^
[INFO] [stdout] 11304 | |                                 _self.into_inner(),
[INFO] [stdout] 11305 | |                                 rhs.into_inner(),
[INFO] [stdout] 11306 | |                             )
[INFO] [stdout] 11307 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11306 -                             )
[INFO] [stdout] 11307 -                             .into();
[INFO] [stdout] 11306 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11303 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::I8Vec4::checked_manhattan_distance(
[INFO] [stdout] 11304 |                                 _self.into_inner(),
[INFO] [stdout] 11305 |                                 rhs.into_inner(),
[INFO] [stdout] 11306 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11465:42
[INFO] [stdout]       |
[INFO] [stdout] 11465 |                           let output: i8 = ::glam::I8Vec4::distance_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11466 | |                                 _self.into_inner(),
[INFO] [stdout] 11467 | |                                 rhs.into_inner(),
[INFO] [stdout] 11468 | |                             )
[INFO] [stdout] 11469 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11468 -                             )
[INFO] [stdout] 11469 -                             .into();
[INFO] [stdout] 11468 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11465 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::distance_squared(
[INFO] [stdout] 11466 |                                 _self.into_inner(),
[INFO] [stdout] 11467 |                                 rhs.into_inner(),
[INFO] [stdout] 11468 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11552:42
[INFO] [stdout]       |
[INFO] [stdout] 11552 |                           let output: i8 = ::glam::I8Vec4::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11553 | |                                 _self.into_inner(),
[INFO] [stdout] 11554 | |                                 rhs.into_inner(),
[INFO] [stdout] 11555 | |                             )
[INFO] [stdout] 11556 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11555 -                             )
[INFO] [stdout] 11556 -                             .into();
[INFO] [stdout] 11555 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11552 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::dot(
[INFO] [stdout] 11553 |                                 _self.into_inner(),
[INFO] [stdout] 11554 |                                 rhs.into_inner(),
[INFO] [stdout] 11555 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11588:42
[INFO] [stdout]       |
[INFO] [stdout] 11588 |                           let output: i8 = ::glam::I8Vec4::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11589 | |                                 _self.into_inner(),
[INFO] [stdout] 11590 | |                             )
[INFO] [stdout] 11591 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11590 -                             )
[INFO] [stdout] 11591 -                             .into();
[INFO] [stdout] 11590 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11588 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::element_product(
[INFO] [stdout] 11589 |                                 _self.into_inner(),
[INFO] [stdout] 11590 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11605:42
[INFO] [stdout]       |
[INFO] [stdout] 11605 |                           let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11606 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11605 -                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout] 11606 -                             .into();
[INFO] [stdout] 11605 +                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11605 -                         let output: i8 = ::glam::I8Vec4::element_sum(_self.into_inner())
[INFO] [stdout] 11606 -                             .into();
[INFO] [stdout] 11605 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:11620:44
[INFO] [stdout]       |
[INFO] [stdout] 11620 |                           let output: bool = <::glam::I8Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 11621 | |                             ::glam::I8Vec4,
[INFO] [stdout] 11622 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 11623 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11622 -                         >>::eq(&_self, &other)
[INFO] [stdout] 11623 -                             .into();
[INFO] [stdout] 11622 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11620 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I8Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 11621 |                             ::glam::I8Vec4,
[INFO] [stdout] 11622 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:11652:43
[INFO] [stdout]       |
[INFO] [stdout] 11652 |                           let output: u32 = ::glam::I8Vec4::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 11653 | |                                 _self.into_inner(),
[INFO] [stdout] 11654 | |                             )
[INFO] [stdout] 11655 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11654 -                             )
[INFO] [stdout] 11655 -                             .into();
[INFO] [stdout] 11654 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11652 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I8Vec4::is_negative_bitmask(
[INFO] [stdout] 11653 |                                 _self.into_inner(),
[INFO] [stdout] 11654 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11686:42
[INFO] [stdout]       |
[INFO] [stdout] 11686 |                           let output: i8 = ::glam::I8Vec4::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11687 | |                                 _self.into_inner(),
[INFO] [stdout] 11688 | |                             )
[INFO] [stdout] 11689 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11688 -                             )
[INFO] [stdout] 11689 -                             .into();
[INFO] [stdout] 11688 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11686 ~                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::length_squared(
[INFO] [stdout] 11687 |                                 _self.into_inner(),
[INFO] [stdout] 11688 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:11703:42
[INFO] [stdout]       |
[INFO] [stdout] 11703 |                           let output: u8 = ::glam::I8Vec4::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11704 | |                                 _self.into_inner(),
[INFO] [stdout] 11705 | |                                 rhs.into_inner(),
[INFO] [stdout] 11706 | |                             )
[INFO] [stdout] 11707 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11706 -                             )
[INFO] [stdout] 11707 -                             .into();
[INFO] [stdout] 11706 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11703 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::I8Vec4::manhattan_distance(
[INFO] [stdout] 11704 |                                 _self.into_inner(),
[INFO] [stdout] 11705 |                                 rhs.into_inner(),
[INFO] [stdout] 11706 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11739:42
[INFO] [stdout]       |
[INFO] [stdout] 11739 |                           let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11740 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11739 -                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout] 11740 -                             .into();
[INFO] [stdout] 11739 +                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11739 -                         let output: i8 = ::glam::I8Vec4::max_element(_self.into_inner())
[INFO] [stdout] 11740 -                             .into();
[INFO] [stdout] 11739 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:11754:45
[INFO] [stdout]       |
[INFO] [stdout] 11754 |                           let output: usize = ::glam::I8Vec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 11755 | |                                 _self.into_inner(),
[INFO] [stdout] 11756 | |                             )
[INFO] [stdout] 11757 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11756 -                             )
[INFO] [stdout] 11757 -                             .into();
[INFO] [stdout] 11756 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11754 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec4::max_position(
[INFO] [stdout] 11755 |                                 _self.into_inner(),
[INFO] [stdout] 11756 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i8`
[INFO] [stdout]      --> src/lib.rs:11789:42
[INFO] [stdout]       |
[INFO] [stdout] 11789 |                           let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 11790 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11789 -                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout] 11790 -                             .into();
[INFO] [stdout] 11789 +                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11789 -                         let output: i8 = ::glam::I8Vec4::min_element(_self.into_inner())
[INFO] [stdout] 11790 -                             .into();
[INFO] [stdout] 11789 +                         let output: i8 = <i8 as Into<_>>::into(::glam::I8Vec4::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:11804:45
[INFO] [stdout]       |
[INFO] [stdout] 11804 |                           let output: usize = ::glam::I8Vec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 11805 | |                                 _self.into_inner(),
[INFO] [stdout] 11806 | |                             )
[INFO] [stdout] 11807 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11806 -                             )
[INFO] [stdout] 11807 -                             .into();
[INFO] [stdout] 11806 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11804 ~                         let output: usize = <usize as Into<_>>::into(::glam::I8Vec4::min_position(
[INFO] [stdout] 11805 |                                 _self.into_inner(),
[INFO] [stdout] 11806 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i8; 4]`
[INFO] [stdout]      --> src/lib.rs:12186:47
[INFO] [stdout]       |
[INFO] [stdout] 12186 |                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12186 -                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout] 12186 +                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12186 -                         let output: [i8; 4] = ::glam::I8Vec4::to_array(&_self).into();
[INFO] [stdout] 12186 +                         let output: [i8; 4] = <[i8; 4] as Into<_>>::into(::glam::I8Vec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:12626:43
[INFO] [stdout]       |
[INFO] [stdout] 12626 |                           let output: u16 = ::glam::I16Vec2::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12627 | |                                 _self.into_inner(),
[INFO] [stdout] 12628 | |                                 rhs.into_inner(),
[INFO] [stdout] 12629 | |                             )
[INFO] [stdout] 12630 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12629 -                             )
[INFO] [stdout] 12630 -                             .into();
[INFO] [stdout] 12629 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12626 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec2::chebyshev_distance(
[INFO] [stdout] 12627 |                                 _self.into_inner(),
[INFO] [stdout] 12628 |                                 rhs.into_inner(),
[INFO] [stdout] 12629 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:12644:67
[INFO] [stdout]       |
[INFO] [stdout] 12644 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec2::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 12645 | |                                 _self.into_inner(),
[INFO] [stdout] 12646 | |                                 rhs.into_inner(),
[INFO] [stdout] 12647 | |                             )
[INFO] [stdout] 12648 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12647 -                             )
[INFO] [stdout] 12648 -                             .into();
[INFO] [stdout] 12647 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12644 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec2::checked_manhattan_distance(
[INFO] [stdout] 12645 |                                 _self.into_inner(),
[INFO] [stdout] 12646 |                                 rhs.into_inner(),
[INFO] [stdout] 12647 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12810:43
[INFO] [stdout]       |
[INFO] [stdout] 12810 |                           let output: i16 = ::glam::I16Vec2::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12811 | |                                 _self.into_inner(),
[INFO] [stdout] 12812 | |                                 rhs.into_inner(),
[INFO] [stdout] 12813 | |                             )
[INFO] [stdout] 12814 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12813 -                             )
[INFO] [stdout] 12814 -                             .into();
[INFO] [stdout] 12813 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12810 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::distance_squared(
[INFO] [stdout] 12811 |                                 _self.into_inner(),
[INFO] [stdout] 12812 |                                 rhs.into_inner(),
[INFO] [stdout] 12813 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12897:43
[INFO] [stdout]       |
[INFO] [stdout] 12897 |                           let output: i16 = ::glam::I16Vec2::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12898 | |                                 _self.into_inner(),
[INFO] [stdout] 12899 | |                                 rhs.into_inner(),
[INFO] [stdout] 12900 | |                             )
[INFO] [stdout] 12901 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12900 -                             )
[INFO] [stdout] 12901 -                             .into();
[INFO] [stdout] 12900 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12897 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::dot(
[INFO] [stdout] 12898 |                                 _self.into_inner(),
[INFO] [stdout] 12899 |                                 rhs.into_inner(),
[INFO] [stdout] 12900 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12933:43
[INFO] [stdout]       |
[INFO] [stdout] 12933 |                           let output: i16 = ::glam::I16Vec2::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12934 | |                                 _self.into_inner(),
[INFO] [stdout] 12935 | |                             )
[INFO] [stdout] 12936 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12935 -                             )
[INFO] [stdout] 12936 -                             .into();
[INFO] [stdout] 12935 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12933 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::element_product(
[INFO] [stdout] 12934 |                                 _self.into_inner(),
[INFO] [stdout] 12935 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:12950:43
[INFO] [stdout]       |
[INFO] [stdout] 12950 |                           let output: i16 = ::glam::I16Vec2::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 12951 | |                                 _self.into_inner(),
[INFO] [stdout] 12952 | |                             )
[INFO] [stdout] 12953 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12952 -                             )
[INFO] [stdout] 12953 -                             .into();
[INFO] [stdout] 12952 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12950 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::element_sum(
[INFO] [stdout] 12951 |                                 _self.into_inner(),
[INFO] [stdout] 12952 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:12967:44
[INFO] [stdout]       |
[INFO] [stdout] 12967 |                           let output: bool = <::glam::I16Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 12968 | |                             ::glam::I16Vec2,
[INFO] [stdout] 12969 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 12970 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12969 -                         >>::eq(&_self, &other)
[INFO] [stdout] 12970 -                             .into();
[INFO] [stdout] 12969 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12967 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 12968 |                             ::glam::I16Vec2,
[INFO] [stdout] 12969 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:13017:43
[INFO] [stdout]       |
[INFO] [stdout] 13017 |                           let output: u32 = ::glam::I16Vec2::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13018 | |                                 _self.into_inner(),
[INFO] [stdout] 13019 | |                             )
[INFO] [stdout] 13020 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13019 -                             )
[INFO] [stdout] 13020 -                             .into();
[INFO] [stdout] 13019 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13017 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec2::is_negative_bitmask(
[INFO] [stdout] 13018 |                                 _self.into_inner(),
[INFO] [stdout] 13019 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13051:43
[INFO] [stdout]       |
[INFO] [stdout] 13051 |                           let output: i16 = ::glam::I16Vec2::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13052 | |                                 _self.into_inner(),
[INFO] [stdout] 13053 | |                             )
[INFO] [stdout] 13054 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13053 -                             )
[INFO] [stdout] 13054 -                             .into();
[INFO] [stdout] 13053 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13051 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::length_squared(
[INFO] [stdout] 13052 |                                 _self.into_inner(),
[INFO] [stdout] 13053 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:13068:43
[INFO] [stdout]       |
[INFO] [stdout] 13068 |                           let output: u16 = ::glam::I16Vec2::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13069 | |                                 _self.into_inner(),
[INFO] [stdout] 13070 | |                                 rhs.into_inner(),
[INFO] [stdout] 13071 | |                             )
[INFO] [stdout] 13072 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13071 -                             )
[INFO] [stdout] 13072 -                             .into();
[INFO] [stdout] 13071 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13068 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec2::manhattan_distance(
[INFO] [stdout] 13069 |                                 _self.into_inner(),
[INFO] [stdout] 13070 |                                 rhs.into_inner(),
[INFO] [stdout] 13071 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13104:43
[INFO] [stdout]       |
[INFO] [stdout] 13104 |                           let output: i16 = ::glam::I16Vec2::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13105 | |                                 _self.into_inner(),
[INFO] [stdout] 13106 | |                             )
[INFO] [stdout] 13107 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13106 -                             )
[INFO] [stdout] 13107 -                             .into();
[INFO] [stdout] 13106 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13104 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::max_element(
[INFO] [stdout] 13105 |                                 _self.into_inner(),
[INFO] [stdout] 13106 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:13121:45
[INFO] [stdout]       |
[INFO] [stdout] 13121 |                           let output: usize = ::glam::I16Vec2::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 13122 | |                                 _self.into_inner(),
[INFO] [stdout] 13123 | |                             )
[INFO] [stdout] 13124 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13123 -                             )
[INFO] [stdout] 13124 -                             .into();
[INFO] [stdout] 13123 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13121 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec2::max_position(
[INFO] [stdout] 13122 |                                 _self.into_inner(),
[INFO] [stdout] 13123 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13156:43
[INFO] [stdout]       |
[INFO] [stdout] 13156 |                           let output: i16 = ::glam::I16Vec2::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13157 | |                                 _self.into_inner(),
[INFO] [stdout] 13158 | |                             )
[INFO] [stdout] 13159 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13158 -                             )
[INFO] [stdout] 13159 -                             .into();
[INFO] [stdout] 13158 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13156 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::min_element(
[INFO] [stdout] 13157 |                                 _self.into_inner(),
[INFO] [stdout] 13158 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:13173:45
[INFO] [stdout]       |
[INFO] [stdout] 13173 |                           let output: usize = ::glam::I16Vec2::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 13174 | |                                 _self.into_inner(),
[INFO] [stdout] 13175 | |                             )
[INFO] [stdout] 13176 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13175 -                             )
[INFO] [stdout] 13176 -                             .into();
[INFO] [stdout] 13175 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13173 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec2::min_position(
[INFO] [stdout] 13174 |                                 _self.into_inner(),
[INFO] [stdout] 13175 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:13290:43
[INFO] [stdout]       |
[INFO] [stdout] 13290 |                           let output: i16 = ::glam::I16Vec2::perp_dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 13291 | |                                 _self.into_inner(),
[INFO] [stdout] 13292 | |                                 rhs.into_inner(),
[INFO] [stdout] 13293 | |                             )
[INFO] [stdout] 13294 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13293 -                             )
[INFO] [stdout] 13294 -                             .into();
[INFO] [stdout] 13293 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13290 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec2::perp_dot(
[INFO] [stdout] 13291 |                                 _self.into_inner(),
[INFO] [stdout] 13292 |                                 rhs.into_inner(),
[INFO] [stdout] 13293 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 2]`
[INFO] [stdout]      --> src/lib.rs:13609:48
[INFO] [stdout]       |
[INFO] [stdout] 13609 |                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13609 -                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout] 13609 +                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13609 -                         let output: [i16; 2] = ::glam::I16Vec2::to_array(&_self).into();
[INFO] [stdout] 13609 +                         let output: [i16; 2] = <[i16; 2] as Into<_>>::into(::glam::I16Vec2::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:14013:43
[INFO] [stdout]       |
[INFO] [stdout] 14013 |                           let output: u16 = ::glam::I16Vec3::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14014 | |                                 _self.into_inner(),
[INFO] [stdout] 14015 | |                                 rhs.into_inner(),
[INFO] [stdout] 14016 | |                             )
[INFO] [stdout] 14017 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14016 -                             )
[INFO] [stdout] 14017 -                             .into();
[INFO] [stdout] 14016 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14013 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec3::chebyshev_distance(
[INFO] [stdout] 14014 |                                 _self.into_inner(),
[INFO] [stdout] 14015 |                                 rhs.into_inner(),
[INFO] [stdout] 14016 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:14031:67
[INFO] [stdout]       |
[INFO] [stdout] 14031 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec3::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 14032 | |                                 _self.into_inner(),
[INFO] [stdout] 14033 | |                                 rhs.into_inner(),
[INFO] [stdout] 14034 | |                             )
[INFO] [stdout] 14035 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14034 -                             )
[INFO] [stdout] 14035 -                             .into();
[INFO] [stdout] 14034 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14031 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec3::checked_manhattan_distance(
[INFO] [stdout] 14032 |                                 _self.into_inner(),
[INFO] [stdout] 14033 |                                 rhs.into_inner(),
[INFO] [stdout] 14034 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14215:43
[INFO] [stdout]       |
[INFO] [stdout] 14215 |                           let output: i16 = ::glam::I16Vec3::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14216 | |                                 _self.into_inner(),
[INFO] [stdout] 14217 | |                                 rhs.into_inner(),
[INFO] [stdout] 14218 | |                             )
[INFO] [stdout] 14219 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14218 -                             )
[INFO] [stdout] 14219 -                             .into();
[INFO] [stdout] 14218 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14215 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::distance_squared(
[INFO] [stdout] 14216 |                                 _self.into_inner(),
[INFO] [stdout] 14217 |                                 rhs.into_inner(),
[INFO] [stdout] 14218 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14302:43
[INFO] [stdout]       |
[INFO] [stdout] 14302 |                           let output: i16 = ::glam::I16Vec3::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14303 | |                                 _self.into_inner(),
[INFO] [stdout] 14304 | |                                 rhs.into_inner(),
[INFO] [stdout] 14305 | |                             )
[INFO] [stdout] 14306 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14305 -                             )
[INFO] [stdout] 14306 -                             .into();
[INFO] [stdout] 14305 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14302 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::dot(
[INFO] [stdout] 14303 |                                 _self.into_inner(),
[INFO] [stdout] 14304 |                                 rhs.into_inner(),
[INFO] [stdout] 14305 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14338:43
[INFO] [stdout]       |
[INFO] [stdout] 14338 |                           let output: i16 = ::glam::I16Vec3::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14339 | |                                 _self.into_inner(),
[INFO] [stdout] 14340 | |                             )
[INFO] [stdout] 14341 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14340 -                             )
[INFO] [stdout] 14341 -                             .into();
[INFO] [stdout] 14340 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14338 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::element_product(
[INFO] [stdout] 14339 |                                 _self.into_inner(),
[INFO] [stdout] 14340 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14355:43
[INFO] [stdout]       |
[INFO] [stdout] 14355 |                           let output: i16 = ::glam::I16Vec3::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14356 | |                                 _self.into_inner(),
[INFO] [stdout] 14357 | |                             )
[INFO] [stdout] 14358 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14357 -                             )
[INFO] [stdout] 14358 -                             .into();
[INFO] [stdout] 14357 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14355 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::element_sum(
[INFO] [stdout] 14356 |                                 _self.into_inner(),
[INFO] [stdout] 14357 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:14372:44
[INFO] [stdout]       |
[INFO] [stdout] 14372 |                           let output: bool = <::glam::I16Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 14373 | |                             ::glam::I16Vec3,
[INFO] [stdout] 14374 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 14375 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14374 -                         >>::eq(&_self, &other)
[INFO] [stdout] 14375 -                             .into();
[INFO] [stdout] 14374 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14372 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 14373 |                             ::glam::I16Vec3,
[INFO] [stdout] 14374 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:14422:43
[INFO] [stdout]       |
[INFO] [stdout] 14422 |                           let output: u32 = ::glam::I16Vec3::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14423 | |                                 _self.into_inner(),
[INFO] [stdout] 14424 | |                             )
[INFO] [stdout] 14425 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14424 -                             )
[INFO] [stdout] 14425 -                             .into();
[INFO] [stdout] 14424 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14422 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec3::is_negative_bitmask(
[INFO] [stdout] 14423 |                                 _self.into_inner(),
[INFO] [stdout] 14424 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14456:43
[INFO] [stdout]       |
[INFO] [stdout] 14456 |                           let output: i16 = ::glam::I16Vec3::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14457 | |                                 _self.into_inner(),
[INFO] [stdout] 14458 | |                             )
[INFO] [stdout] 14459 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14458 -                             )
[INFO] [stdout] 14459 -                             .into();
[INFO] [stdout] 14458 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14456 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::length_squared(
[INFO] [stdout] 14457 |                                 _self.into_inner(),
[INFO] [stdout] 14458 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:14473:43
[INFO] [stdout]       |
[INFO] [stdout] 14473 |                           let output: u16 = ::glam::I16Vec3::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14474 | |                                 _self.into_inner(),
[INFO] [stdout] 14475 | |                                 rhs.into_inner(),
[INFO] [stdout] 14476 | |                             )
[INFO] [stdout] 14477 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14476 -                             )
[INFO] [stdout] 14477 -                             .into();
[INFO] [stdout] 14476 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14473 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec3::manhattan_distance(
[INFO] [stdout] 14474 |                                 _self.into_inner(),
[INFO] [stdout] 14475 |                                 rhs.into_inner(),
[INFO] [stdout] 14476 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14509:43
[INFO] [stdout]       |
[INFO] [stdout] 14509 |                           let output: i16 = ::glam::I16Vec3::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14510 | |                                 _self.into_inner(),
[INFO] [stdout] 14511 | |                             )
[INFO] [stdout] 14512 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14511 -                             )
[INFO] [stdout] 14512 -                             .into();
[INFO] [stdout] 14511 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14509 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::max_element(
[INFO] [stdout] 14510 |                                 _self.into_inner(),
[INFO] [stdout] 14511 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:14526:45
[INFO] [stdout]       |
[INFO] [stdout] 14526 |                           let output: usize = ::glam::I16Vec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 14527 | |                                 _self.into_inner(),
[INFO] [stdout] 14528 | |                             )
[INFO] [stdout] 14529 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14528 -                             )
[INFO] [stdout] 14529 -                             .into();
[INFO] [stdout] 14528 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14526 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec3::max_position(
[INFO] [stdout] 14527 |                                 _self.into_inner(),
[INFO] [stdout] 14528 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:14561:43
[INFO] [stdout]       |
[INFO] [stdout] 14561 |                           let output: i16 = ::glam::I16Vec3::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 14562 | |                                 _self.into_inner(),
[INFO] [stdout] 14563 | |                             )
[INFO] [stdout] 14564 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14563 -                             )
[INFO] [stdout] 14564 -                             .into();
[INFO] [stdout] 14563 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14561 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec3::min_element(
[INFO] [stdout] 14562 |                                 _self.into_inner(),
[INFO] [stdout] 14563 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:14578:45
[INFO] [stdout]       |
[INFO] [stdout] 14578 |                           let output: usize = ::glam::I16Vec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 14579 | |                                 _self.into_inner(),
[INFO] [stdout] 14580 | |                             )
[INFO] [stdout] 14581 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14580 -                             )
[INFO] [stdout] 14581 -                             .into();
[INFO] [stdout] 14580 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14578 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec3::min_position(
[INFO] [stdout] 14579 |                                 _self.into_inner(),
[INFO] [stdout] 14580 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 3]`
[INFO] [stdout]      --> src/lib.rs:14961:48
[INFO] [stdout]       |
[INFO] [stdout] 14961 |                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 14961 -                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout] 14961 +                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 14961 -                         let output: [i16; 3] = ::glam::I16Vec3::to_array(&_self).into();
[INFO] [stdout] 14961 +                         let output: [i16; 3] = <[i16; 3] as Into<_>>::into(::glam::I16Vec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:15383:43
[INFO] [stdout]       |
[INFO] [stdout] 15383 |                           let output: u16 = ::glam::I16Vec4::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15384 | |                                 _self.into_inner(),
[INFO] [stdout] 15385 | |                                 rhs.into_inner(),
[INFO] [stdout] 15386 | |                             )
[INFO] [stdout] 15387 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15386 -                             )
[INFO] [stdout] 15387 -                             .into();
[INFO] [stdout] 15386 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15383 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec4::chebyshev_distance(
[INFO] [stdout] 15384 |                                 _self.into_inner(),
[INFO] [stdout] 15385 |                                 rhs.into_inner(),
[INFO] [stdout] 15386 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:15401:67
[INFO] [stdout]       |
[INFO] [stdout] 15401 |                           let output: ::core::option::Option<u16> = ::glam::I16Vec4::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 15402 | |                                 _self.into_inner(),
[INFO] [stdout] 15403 | |                                 rhs.into_inner(),
[INFO] [stdout] 15404 | |                             )
[INFO] [stdout] 15405 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15404 -                             )
[INFO] [stdout] 15405 -                             .into();
[INFO] [stdout] 15404 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15401 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::I16Vec4::checked_manhattan_distance(
[INFO] [stdout] 15402 |                                 _self.into_inner(),
[INFO] [stdout] 15403 |                                 rhs.into_inner(),
[INFO] [stdout] 15404 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15567:43
[INFO] [stdout]       |
[INFO] [stdout] 15567 |                           let output: i16 = ::glam::I16Vec4::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15568 | |                                 _self.into_inner(),
[INFO] [stdout] 15569 | |                                 rhs.into_inner(),
[INFO] [stdout] 15570 | |                             )
[INFO] [stdout] 15571 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15570 -                             )
[INFO] [stdout] 15571 -                             .into();
[INFO] [stdout] 15570 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15567 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::distance_squared(
[INFO] [stdout] 15568 |                                 _self.into_inner(),
[INFO] [stdout] 15569 |                                 rhs.into_inner(),
[INFO] [stdout] 15570 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15654:43
[INFO] [stdout]       |
[INFO] [stdout] 15654 |                           let output: i16 = ::glam::I16Vec4::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15655 | |                                 _self.into_inner(),
[INFO] [stdout] 15656 | |                                 rhs.into_inner(),
[INFO] [stdout] 15657 | |                             )
[INFO] [stdout] 15658 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15657 -                             )
[INFO] [stdout] 15658 -                             .into();
[INFO] [stdout] 15657 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15654 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::dot(
[INFO] [stdout] 15655 |                                 _self.into_inner(),
[INFO] [stdout] 15656 |                                 rhs.into_inner(),
[INFO] [stdout] 15657 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15690:43
[INFO] [stdout]       |
[INFO] [stdout] 15690 |                           let output: i16 = ::glam::I16Vec4::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15691 | |                                 _self.into_inner(),
[INFO] [stdout] 15692 | |                             )
[INFO] [stdout] 15693 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15692 -                             )
[INFO] [stdout] 15693 -                             .into();
[INFO] [stdout] 15692 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15690 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::element_product(
[INFO] [stdout] 15691 |                                 _self.into_inner(),
[INFO] [stdout] 15692 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15707:43
[INFO] [stdout]       |
[INFO] [stdout] 15707 |                           let output: i16 = ::glam::I16Vec4::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15708 | |                                 _self.into_inner(),
[INFO] [stdout] 15709 | |                             )
[INFO] [stdout] 15710 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15709 -                             )
[INFO] [stdout] 15710 -                             .into();
[INFO] [stdout] 15709 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15707 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::element_sum(
[INFO] [stdout] 15708 |                                 _self.into_inner(),
[INFO] [stdout] 15709 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:15724:44
[INFO] [stdout]       |
[INFO] [stdout] 15724 |                           let output: bool = <::glam::I16Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 15725 | |                             ::glam::I16Vec4,
[INFO] [stdout] 15726 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 15727 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15726 -                         >>::eq(&_self, &other)
[INFO] [stdout] 15727 -                             .into();
[INFO] [stdout] 15726 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15724 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I16Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 15725 |                             ::glam::I16Vec4,
[INFO] [stdout] 15726 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:15756:43
[INFO] [stdout]       |
[INFO] [stdout] 15756 |                           let output: u32 = ::glam::I16Vec4::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15757 | |                                 _self.into_inner(),
[INFO] [stdout] 15758 | |                             )
[INFO] [stdout] 15759 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15758 -                             )
[INFO] [stdout] 15759 -                             .into();
[INFO] [stdout] 15758 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15756 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I16Vec4::is_negative_bitmask(
[INFO] [stdout] 15757 |                                 _self.into_inner(),
[INFO] [stdout] 15758 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15790:43
[INFO] [stdout]       |
[INFO] [stdout] 15790 |                           let output: i16 = ::glam::I16Vec4::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15791 | |                                 _self.into_inner(),
[INFO] [stdout] 15792 | |                             )
[INFO] [stdout] 15793 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15792 -                             )
[INFO] [stdout] 15793 -                             .into();
[INFO] [stdout] 15792 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15790 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::length_squared(
[INFO] [stdout] 15791 |                                 _self.into_inner(),
[INFO] [stdout] 15792 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:15807:43
[INFO] [stdout]       |
[INFO] [stdout] 15807 |                           let output: u16 = ::glam::I16Vec4::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15808 | |                                 _self.into_inner(),
[INFO] [stdout] 15809 | |                                 rhs.into_inner(),
[INFO] [stdout] 15810 | |                             )
[INFO] [stdout] 15811 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15810 -                             )
[INFO] [stdout] 15811 -                             .into();
[INFO] [stdout] 15810 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15807 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::I16Vec4::manhattan_distance(
[INFO] [stdout] 15808 |                                 _self.into_inner(),
[INFO] [stdout] 15809 |                                 rhs.into_inner(),
[INFO] [stdout] 15810 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15843:43
[INFO] [stdout]       |
[INFO] [stdout] 15843 |                           let output: i16 = ::glam::I16Vec4::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15844 | |                                 _self.into_inner(),
[INFO] [stdout] 15845 | |                             )
[INFO] [stdout] 15846 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15845 -                             )
[INFO] [stdout] 15846 -                             .into();
[INFO] [stdout] 15845 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15843 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::max_element(
[INFO] [stdout] 15844 |                                 _self.into_inner(),
[INFO] [stdout] 15845 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:15860:45
[INFO] [stdout]       |
[INFO] [stdout] 15860 |                           let output: usize = ::glam::I16Vec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 15861 | |                                 _self.into_inner(),
[INFO] [stdout] 15862 | |                             )
[INFO] [stdout] 15863 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15862 -                             )
[INFO] [stdout] 15863 -                             .into();
[INFO] [stdout] 15862 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15860 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec4::max_position(
[INFO] [stdout] 15861 |                                 _self.into_inner(),
[INFO] [stdout] 15862 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i16`
[INFO] [stdout]      --> src/lib.rs:15895:43
[INFO] [stdout]       |
[INFO] [stdout] 15895 |                           let output: i16 = ::glam::I16Vec4::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 15896 | |                                 _self.into_inner(),
[INFO] [stdout] 15897 | |                             )
[INFO] [stdout] 15898 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15897 -                             )
[INFO] [stdout] 15898 -                             .into();
[INFO] [stdout] 15897 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15895 ~                         let output: i16 = <i16 as Into<_>>::into(::glam::I16Vec4::min_element(
[INFO] [stdout] 15896 |                                 _self.into_inner(),
[INFO] [stdout] 15897 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:42:44
[INFO] [stdout]    |
[INFO] [stdout] 42 |                           let output: bool = <::core::ops::RangeFull as ::core::cmp::PartialEq<
[INFO] [stdout]    |  ____________________________________________^
[INFO] [stdout] 43 | |                             ::core::ops::RangeFull,
[INFO] [stdout] 44 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 45 | |                             .into();
[INFO] [stdout]    | |___________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a 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] 44 -                         >>::eq(&_self, &other)
[INFO] [stdout] 45 -                             .into();
[INFO] [stdout] 44 +                         >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 ~                         let output: bool = <bool as Into<_>>::into(<::core::ops::RangeFull as ::core::cmp::PartialEq<
[INFO] [stdout] 43 |                             ::core::ops::RangeFull,
[INFO] [stdout] 44 ~                         >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:15912:45
[INFO] [stdout]       |
[INFO] [stdout] 15912 |                           let output: usize = ::glam::I16Vec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 15913 | |                                 _self.into_inner(),
[INFO] [stdout] 15914 | |                             )
[INFO] [stdout] 15915 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15914 -                             )
[INFO] [stdout] 15915 -                             .into();
[INFO] [stdout] 15914 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15912 ~                         let output: usize = <usize as Into<_>>::into(::glam::I16Vec4::min_position(
[INFO] [stdout] 15913 |                                 _self.into_inner(),
[INFO] [stdout] 15914 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/lib.rs:84:40
[INFO] [stdout]    |
[INFO] [stdout] 84 |                       let output: bool = <::core::any::TypeId as ::core::cmp::PartialEq<
[INFO] [stdout]    |  ________________________________________^
[INFO] [stdout] 85 | |                         ::core::any::TypeId,
[INFO] [stdout] 86 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 87 | |                     .into();
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 86 -                     >>::eq(&_self, &other)
[INFO] [stdout] 87 -                     .into();
[INFO] [stdout] 86 +                     >>::eq(&_self, &other);
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 ~                     let output: bool = <bool as Into<_>>::into(<::core::any::TypeId as ::core::cmp::PartialEq<
[INFO] [stdout] 85 |                         ::core::any::TypeId,
[INFO] [stdout] 86 ~                     >>::eq(&_self, &other));
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:110:44
[INFO] [stdout]     |
[INFO] [stdout] 110 |                           let output: bool = ::glam::Quat::abs_diff_eq(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 111 | |                                 _self.into_inner(),
[INFO] [stdout] 112 | |                                 rhs.into_inner(),
[INFO] [stdout] 113 | |                                 max_abs_diff,
[INFO] [stdout] 114 | |                             )
[INFO] [stdout] 115 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 114 -                             )
[INFO] [stdout] 115 -                             .into();
[INFO] [stdout] 114 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::abs_diff_eq(
[INFO] [stdout] 111 |                                 _self.into_inner(),
[INFO] [stdout] 112 |                                 rhs.into_inner(),
[INFO] [stdout] 113 |                                 max_abs_diff,
[INFO] [stdout] 114 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i16; 4]`
[INFO] [stdout]      --> src/lib.rs:16295:48
[INFO] [stdout]       |
[INFO] [stdout] 16295 |                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16295 -                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout] 16295 +                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16295 -                         let output: [i16; 4] = ::glam::I16Vec4::to_array(&_self).into();
[INFO] [stdout] 16295 +                         let output: [i16; 4] = <[i16; 4] as Into<_>>::into(::glam::I16Vec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:163:43
[INFO] [stdout]     |
[INFO] [stdout] 163 |                           let output: f32 = ::glam::Quat::angle_between(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 164 | |                                 _self.into_inner(),
[INFO] [stdout] 165 | |                                 rhs.into_inner(),
[INFO] [stdout] 166 | |                             )
[INFO] [stdout] 167 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 166 -                             )
[INFO] [stdout] 167 -                             .into();
[INFO] [stdout] 166 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::angle_between(
[INFO] [stdout] 164 |                                 _self.into_inner(),
[INFO] [stdout] 165 |                                 rhs.into_inner(),
[INFO] [stdout] 166 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:249:43
[INFO] [stdout]     |
[INFO] [stdout] 249 |                           let output: f32 = ::glam::Quat::dot(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 250 | |                                 _self.into_inner(),
[INFO] [stdout] 251 | |                                 rhs.into_inner(),
[INFO] [stdout] 252 | |                             )
[INFO] [stdout] 253 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 252 -                             )
[INFO] [stdout] 253 -                             .into();
[INFO] [stdout] 252 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::dot(
[INFO] [stdout] 250 |                                 _self.into_inner(),
[INFO] [stdout] 251 |                                 rhs.into_inner(),
[INFO] [stdout] 252 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:267:44
[INFO] [stdout]     |
[INFO] [stdout] 267 |                           let output: bool = <::glam::Quat as ::core::cmp::PartialEq<
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 268 | |                             ::glam::Quat,
[INFO] [stdout] 269 | |                         >>::eq(&_self, &rhs)
[INFO] [stdout] 270 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 269 -                         >>::eq(&_self, &rhs)
[INFO] [stdout] 270 -                             .into();
[INFO] [stdout] 269 +                         >>::eq(&_self, &rhs);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 ~                         let output: bool = <bool as Into<_>>::into(<::glam::Quat as ::core::cmp::PartialEq<
[INFO] [stdout] 268 |                             ::glam::Quat,
[INFO] [stdout] 269 ~                         >>::eq(&_self, &rhs));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/lib.rs:16735:43
[INFO] [stdout]       |
[INFO] [stdout] 16735 |                           let output: u64 = ::glam::I64Vec2::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 16736 | |                                 _self.into_inner(),
[INFO] [stdout] 16737 | |                                 rhs.into_inner(),
[INFO] [stdout] 16738 | |                             )
[INFO] [stdout] 16739 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16738 -                             )
[INFO] [stdout] 16739 -                             .into();
[INFO] [stdout] 16738 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16735 ~                         let output: u64 = <u64 as Into<_>>::into(::glam::I64Vec2::chebyshev_distance(
[INFO] [stdout] 16736 |                                 _self.into_inner(),
[INFO] [stdout] 16737 |                                 rhs.into_inner(),
[INFO] [stdout] 16738 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:601:44
[INFO] [stdout]     |
[INFO] [stdout] 601 |                           let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 602 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 601 -                         let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout] 602 -                             .into();
[INFO] [stdout] 601 +                         let output: bool = ::glam::Quat::is_finite(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 601 -                         let output: bool = ::glam::Quat::is_finite(_self.into_inner())
[INFO] [stdout] 602 -                             .into();
[INFO] [stdout] 601 +                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_finite(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:616:44
[INFO] [stdout]     |
[INFO] [stdout] 616 |                           let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 617 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                         let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout] 617 -                             .into();
[INFO] [stdout] 616 +                         let output: bool = ::glam::Quat::is_nan(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 616 -                         let output: bool = ::glam::Quat::is_nan(_self.into_inner())
[INFO] [stdout] 617 -                             .into();
[INFO] [stdout] 616 +                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_nan(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:631:44
[INFO] [stdout]     |
[INFO] [stdout] 631 |                           let output: bool = ::glam::Quat::is_near_identity(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 632 | |                                 _self.into_inner(),
[INFO] [stdout] 633 | |                             )
[INFO] [stdout] 634 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 633 -                             )
[INFO] [stdout] 634 -                             .into();
[INFO] [stdout] 633 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 631 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_near_identity(
[INFO] [stdout] 632 |                                 _self.into_inner(),
[INFO] [stdout] 633 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u64>`
[INFO] [stdout]      --> src/lib.rs:16753:67
[INFO] [stdout]       |
[INFO] [stdout] 16753 |                           let output: ::core::option::Option<u64> = ::glam::I64Vec2::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 16754 | |                                 _self.into_inner(),
[INFO] [stdout] 16755 | |                                 rhs.into_inner(),
[INFO] [stdout] 16756 | |                             )
[INFO] [stdout] 16757 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16756 -                             )
[INFO] [stdout] 16757 -                             .into();
[INFO] [stdout] 16756 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16753 ~                         let output: ::core::option::Option<u64> = <std::option::Option<u64> as Into<_>>::into(::glam::I64Vec2::checked_manhattan_distance(
[INFO] [stdout] 16754 |                                 _self.into_inner(),
[INFO] [stdout] 16755 |                                 rhs.into_inner(),
[INFO] [stdout] 16756 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]    --> src/lib.rs:648:44
[INFO] [stdout]     |
[INFO] [stdout] 648 |                           let output: bool = ::glam::Quat::is_normalized(
[INFO] [stdout]     |  ____________________________________________^
[INFO] [stdout] 649 | |                                 _self.into_inner(),
[INFO] [stdout] 650 | |                             )
[INFO] [stdout] 651 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 650 -                             )
[INFO] [stdout] 651 -                             .into();
[INFO] [stdout] 650 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 648 ~                         let output: bool = <bool as Into<_>>::into(::glam::Quat::is_normalized(
[INFO] [stdout] 649 |                                 _self.into_inner(),
[INFO] [stdout] 650 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:665:43
[INFO] [stdout]     |
[INFO] [stdout] 665 |                           let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 666 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 665 -                         let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout] 666 -                             .into();
[INFO] [stdout] 665 +                         let output: f32 = ::glam::Quat::length(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 665 -                         let output: f32 = ::glam::Quat::length(_self.into_inner())
[INFO] [stdout] 666 -                             .into();
[INFO] [stdout] 665 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:680:43
[INFO] [stdout]     |
[INFO] [stdout] 680 |                           let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 681 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 680 -                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout] 681 -                             .into();
[INFO] [stdout] 680 +                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 680 -                         let output: f32 = ::glam::Quat::length_recip(_self.into_inner())
[INFO] [stdout] 681 -                             .into();
[INFO] [stdout] 680 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length_recip(_self.into_inner()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:16919:43
[INFO] [stdout]       |
[INFO] [stdout] 16919 |                           let output: i64 = ::glam::I64Vec2::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 16920 | |                                 _self.into_inner(),
[INFO] [stdout] 16921 | |                                 rhs.into_inner(),
[INFO] [stdout] 16922 | |                             )
[INFO] [stdout] 16923 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16922 -                             )
[INFO] [stdout] 16923 -                             .into();
[INFO] [stdout] 16922 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16919 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::distance_squared(
[INFO] [stdout] 16920 |                                 _self.into_inner(),
[INFO] [stdout] 16921 |                                 rhs.into_inner(),
[INFO] [stdout] 16922 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/lib.rs:695:43
[INFO] [stdout]     |
[INFO] [stdout] 695 |                           let output: f32 = ::glam::Quat::length_squared(
[INFO] [stdout]     |  ___________________________________________^
[INFO] [stdout] 696 | |                                 _self.into_inner(),
[INFO] [stdout] 697 | |                             )
[INFO] [stdout] 698 | |                             .into();
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 697 -                             )
[INFO] [stdout] 698 -                             .into();
[INFO] [stdout] 697 +                             );
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Quat::length_squared(
[INFO] [stdout] 696 |                                 _self.into_inner(),
[INFO] [stdout] 697 ~                             ));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:17006:43
[INFO] [stdout]       |
[INFO] [stdout] 17006 |                           let output: i64 = ::glam::I64Vec2::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17007 | |                                 _self.into_inner(),
[INFO] [stdout] 17008 | |                                 rhs.into_inner(),
[INFO] [stdout] 17009 | |                             )
[INFO] [stdout] 17010 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17009 -                             )
[INFO] [stdout] 17010 -                             .into();
[INFO] [stdout] 17009 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17006 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::dot(
[INFO] [stdout] 17007 |                                 _self.into_inner(),
[INFO] [stdout] 17008 |                                 rhs.into_inner(),
[INFO] [stdout] 17009 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:17042:43
[INFO] [stdout]       |
[INFO] [stdout] 17042 |                           let output: i64 = ::glam::I64Vec2::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17043 | |                                 _self.into_inner(),
[INFO] [stdout] 17044 | |                             )
[INFO] [stdout] 17045 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17044 -                             )
[INFO] [stdout] 17045 -                             .into();
[INFO] [stdout] 17044 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17042 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::element_product(
[INFO] [stdout] 17043 |                                 _self.into_inner(),
[INFO] [stdout] 17044 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[f32; 4]`
[INFO] [stdout]     --> src/lib.rs:1069:48
[INFO] [stdout]      |
[INFO] [stdout] 1069 |                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1069 -                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout] 1069 +                         let output: [f32; 4] = ::glam::Quat::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1069 -                         let output: [f32; 4] = ::glam::Quat::to_array(&_self).into();
[INFO] [stdout] 1069 +                         let output: [f32; 4] = <[f32; 4] as Into<_>>::into(::glam::Quat::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:17059:43
[INFO] [stdout]       |
[INFO] [stdout] 17059 |                           let output: i64 = ::glam::I64Vec2::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17060 | |                                 _self.into_inner(),
[INFO] [stdout] 17061 | |                             )
[INFO] [stdout] 17062 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17061 -                             )
[INFO] [stdout] 17062 -                             .into();
[INFO] [stdout] 17061 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17059 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::element_sum(
[INFO] [stdout] 17060 |                                 _self.into_inner(),
[INFO] [stdout] 17061 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `(f32, f32, f32)`
[INFO] [stdout]     --> src/lib.rs:1083:55
[INFO] [stdout]      |
[INFO] [stdout] 1083 |                           let output: (f32, f32, f32) = ::glam::Quat::to_euler(
[INFO] [stdout]      |  _______________________________________________________^
[INFO] [stdout] 1084 | |                                 _self.into_inner(),
[INFO] [stdout] 1085 | |                                 order.into_inner(),
[INFO] [stdout] 1086 | |                             )
[INFO] [stdout] 1087 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1086 -                             )
[INFO] [stdout] 1087 -                             .into();
[INFO] [stdout] 1086 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1083 ~                         let output: (f32, f32, f32) = <(f32, f32, f32) as Into<_>>::into(::glam::Quat::to_euler(
[INFO] [stdout] 1084 |                                 _self.into_inner(),
[INFO] [stdout] 1085 |                                 order.into_inner(),
[INFO] [stdout] 1086 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:17076:44
[INFO] [stdout]       |
[INFO] [stdout] 17076 |                           let output: bool = <::glam::I64Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 17077 | |                             ::glam::I64Vec2,
[INFO] [stdout] 17078 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 17079 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17078 -                         >>::eq(&_self, &other)
[INFO] [stdout] 17079 -                             .into();
[INFO] [stdout] 17078 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17076 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I64Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 17077 |                             ::glam::I64Vec2,
[INFO] [stdout] 17078 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:17126:43
[INFO] [stdout]       |
[INFO] [stdout] 17126 |                           let output: u32 = ::glam::I64Vec2::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17127 | |                                 _self.into_inner(),
[INFO] [stdout] 17128 | |                             )
[INFO] [stdout] 17129 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17128 -                             )
[INFO] [stdout] 17129 -                             .into();
[INFO] [stdout] 17128 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17126 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I64Vec2::is_negative_bitmask(
[INFO] [stdout] 17127 |                                 _self.into_inner(),
[INFO] [stdout] 17128 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1160:44
[INFO] [stdout]      |
[INFO] [stdout] 1160 |                           let output: bool = ::glam::Vec3::abs_diff_eq(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1161 | |                                 _self.into_inner(),
[INFO] [stdout] 1162 | |                                 rhs.into_inner(),
[INFO] [stdout] 1163 | |                                 max_abs_diff,
[INFO] [stdout] 1164 | |                             )
[INFO] [stdout] 1165 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1164 -                             )
[INFO] [stdout] 1165 -                             .into();
[INFO] [stdout] 1164 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1160 ~                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::abs_diff_eq(
[INFO] [stdout] 1161 |                                 _self.into_inner(),
[INFO] [stdout] 1162 |                                 rhs.into_inner(),
[INFO] [stdout] 1163 |                                 max_abs_diff,
[INFO] [stdout] 1164 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:17160:43
[INFO] [stdout]       |
[INFO] [stdout] 17160 |                           let output: i64 = ::glam::I64Vec2::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17161 | |                                 _self.into_inner(),
[INFO] [stdout] 17162 | |                             )
[INFO] [stdout] 17163 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17162 -                             )
[INFO] [stdout] 17163 -                             .into();
[INFO] [stdout] 17162 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17160 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::length_squared(
[INFO] [stdout] 17161 |                                 _self.into_inner(),
[INFO] [stdout] 17162 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1230:43
[INFO] [stdout]      |
[INFO] [stdout] 1230 |                           let output: f32 = ::glam::Vec3::angle_between(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1231 | |                                 _self.into_inner(),
[INFO] [stdout] 1232 | |                                 rhs.into_inner(),
[INFO] [stdout] 1233 | |                             )
[INFO] [stdout] 1234 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1233 -                             )
[INFO] [stdout] 1234 -                             .into();
[INFO] [stdout] 1233 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1230 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::angle_between(
[INFO] [stdout] 1231 |                                 _self.into_inner(),
[INFO] [stdout] 1232 |                                 rhs.into_inner(),
[INFO] [stdout] 1233 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/lib.rs:17177:43
[INFO] [stdout]       |
[INFO] [stdout] 17177 |                           let output: u64 = ::glam::I64Vec2::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17178 | |                                 _self.into_inner(),
[INFO] [stdout] 17179 | |                                 rhs.into_inner(),
[INFO] [stdout] 17180 | |                             )
[INFO] [stdout] 17181 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17180 -                             )
[INFO] [stdout] 17181 -                             .into();
[INFO] [stdout] 17180 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17177 ~                         let output: u64 = <u64 as Into<_>>::into(::glam::I64Vec2::manhattan_distance(
[INFO] [stdout] 17178 |                                 _self.into_inner(),
[INFO] [stdout] 17179 |                                 rhs.into_inner(),
[INFO] [stdout] 17180 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1248:43
[INFO] [stdout]      |
[INFO] [stdout] 1248 |                           let output: f32 = ::glam::Vec3::angle_to(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1249 | |                                 _self.into_inner(),
[INFO] [stdout] 1250 | |                                 rhs.into_inner(),
[INFO] [stdout] 1251 | |                                 axis.into_inner(),
[INFO] [stdout] 1252 | |                             )
[INFO] [stdout] 1253 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1252 -                             )
[INFO] [stdout] 1253 -                             .into();
[INFO] [stdout] 1252 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1248 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::angle_to(
[INFO] [stdout] 1249 |                                 _self.into_inner(),
[INFO] [stdout] 1250 |                                 rhs.into_inner(),
[INFO] [stdout] 1251 |                                 axis.into_inner(),
[INFO] [stdout] 1252 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:17213:43
[INFO] [stdout]       |
[INFO] [stdout] 17213 |                           let output: i64 = ::glam::I64Vec2::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17214 | |                                 _self.into_inner(),
[INFO] [stdout] 17215 | |                             )
[INFO] [stdout] 17216 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17215 -                             )
[INFO] [stdout] 17216 -                             .into();
[INFO] [stdout] 17215 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17213 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::max_element(
[INFO] [stdout] 17214 |                                 _self.into_inner(),
[INFO] [stdout] 17215 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:17230:45
[INFO] [stdout]       |
[INFO] [stdout] 17230 |                           let output: usize = ::glam::I64Vec2::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 17231 | |                                 _self.into_inner(),
[INFO] [stdout] 17232 | |                             )
[INFO] [stdout] 17233 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17232 -                             )
[INFO] [stdout] 17233 -                             .into();
[INFO] [stdout] 17232 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17230 ~                         let output: usize = <usize as Into<_>>::into(::glam::I64Vec2::max_position(
[INFO] [stdout] 17231 |                                 _self.into_inner(),
[INFO] [stdout] 17232 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1723:43
[INFO] [stdout]      |
[INFO] [stdout] 1723 |                           let output: f32 = ::glam::Vec3::distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1724 | |                                 _self.into_inner(),
[INFO] [stdout] 1725 | |                                 rhs.into_inner(),
[INFO] [stdout] 1726 | |                             )
[INFO] [stdout] 1727 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1726 -                             )
[INFO] [stdout] 1727 -                             .into();
[INFO] [stdout] 1726 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1723 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::distance(
[INFO] [stdout] 1724 |                                 _self.into_inner(),
[INFO] [stdout] 1725 |                                 rhs.into_inner(),
[INFO] [stdout] 1726 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:17265:43
[INFO] [stdout]       |
[INFO] [stdout] 17265 |                           let output: i64 = ::glam::I64Vec2::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17266 | |                                 _self.into_inner(),
[INFO] [stdout] 17267 | |                             )
[INFO] [stdout] 17268 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17267 -                             )
[INFO] [stdout] 17268 -                             .into();
[INFO] [stdout] 17267 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17265 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::min_element(
[INFO] [stdout] 17266 |                                 _self.into_inner(),
[INFO] [stdout] 17267 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1741:43
[INFO] [stdout]      |
[INFO] [stdout] 1741 |                           let output: f32 = ::glam::Vec3::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1742 | |                                 _self.into_inner(),
[INFO] [stdout] 1743 | |                                 rhs.into_inner(),
[INFO] [stdout] 1744 | |                             )
[INFO] [stdout] 1745 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1744 -                             )
[INFO] [stdout] 1745 -                             .into();
[INFO] [stdout] 1744 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1741 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::distance_squared(
[INFO] [stdout] 1742 |                                 _self.into_inner(),
[INFO] [stdout] 1743 |                                 rhs.into_inner(),
[INFO] [stdout] 1744 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:17282:45
[INFO] [stdout]       |
[INFO] [stdout] 17282 |                           let output: usize = ::glam::I64Vec2::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 17283 | |                                 _self.into_inner(),
[INFO] [stdout] 17284 | |                             )
[INFO] [stdout] 17285 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17284 -                             )
[INFO] [stdout] 17285 -                             .into();
[INFO] [stdout] 17284 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17282 ~                         let output: usize = <usize as Into<_>>::into(::glam::I64Vec2::min_position(
[INFO] [stdout] 17283 |                                 _self.into_inner(),
[INFO] [stdout] 17284 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1828:43
[INFO] [stdout]      |
[INFO] [stdout] 1828 |                           let output: f32 = ::glam::Vec3::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1829 | |                                 _self.into_inner(),
[INFO] [stdout] 1830 | |                                 rhs.into_inner(),
[INFO] [stdout] 1831 | |                             )
[INFO] [stdout] 1832 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1831 -                             )
[INFO] [stdout] 1832 -                             .into();
[INFO] [stdout] 1831 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1828 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::dot(
[INFO] [stdout] 1829 |                                 _self.into_inner(),
[INFO] [stdout] 1830 |                                 rhs.into_inner(),
[INFO] [stdout] 1831 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:17399:43
[INFO] [stdout]       |
[INFO] [stdout] 17399 |                           let output: i64 = ::glam::I64Vec2::perp_dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 17400 | |                                 _self.into_inner(),
[INFO] [stdout] 17401 | |                                 rhs.into_inner(),
[INFO] [stdout] 17402 | |                             )
[INFO] [stdout] 17403 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17402 -                             )
[INFO] [stdout] 17403 -                             .into();
[INFO] [stdout] 17402 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17399 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec2::perp_dot(
[INFO] [stdout] 17400 |                                 _self.into_inner(),
[INFO] [stdout] 17401 |                                 rhs.into_inner(),
[INFO] [stdout] 17402 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1864:43
[INFO] [stdout]      |
[INFO] [stdout] 1864 |                           let output: f32 = ::glam::Vec3::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1865 | |                                 _self.into_inner(),
[INFO] [stdout] 1866 | |                             )
[INFO] [stdout] 1867 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1866 -                             )
[INFO] [stdout] 1867 -                             .into();
[INFO] [stdout] 1866 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1864 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::element_product(
[INFO] [stdout] 1865 |                                 _self.into_inner(),
[INFO] [stdout] 1866 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i64; 2]`
[INFO] [stdout]      --> src/lib.rs:17718:48
[INFO] [stdout]       |
[INFO] [stdout] 17718 |                         let output: [i64; 2] = ::glam::I64Vec2::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 17718 -                         let output: [i64; 2] = ::glam::I64Vec2::to_array(&_self).into();
[INFO] [stdout] 17718 +                         let output: [i64; 2] = ::glam::I64Vec2::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 17718 -                         let output: [i64; 2] = ::glam::I64Vec2::to_array(&_self).into();
[INFO] [stdout] 17718 +                         let output: [i64; 2] = <[i64; 2] as Into<_>>::into(::glam::I64Vec2::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:1881:43
[INFO] [stdout]      |
[INFO] [stdout] 1881 |                           let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 1882 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1881 -                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 1882 -                             .into();
[INFO] [stdout] 1881 +                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1881 -                         let output: f32 = ::glam::Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 1882 -                             .into();
[INFO] [stdout] 1881 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/lib.rs:18122:43
[INFO] [stdout]       |
[INFO] [stdout] 18122 |                           let output: u64 = ::glam::I64Vec3::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18123 | |                                 _self.into_inner(),
[INFO] [stdout] 18124 | |                                 rhs.into_inner(),
[INFO] [stdout] 18125 | |                             )
[INFO] [stdout] 18126 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18125 -                             )
[INFO] [stdout] 18126 -                             .into();
[INFO] [stdout] 18125 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18122 ~                         let output: u64 = <u64 as Into<_>>::into(::glam::I64Vec3::chebyshev_distance(
[INFO] [stdout] 18123 |                                 _self.into_inner(),
[INFO] [stdout] 18124 |                                 rhs.into_inner(),
[INFO] [stdout] 18125 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:1896:44
[INFO] [stdout]      |
[INFO] [stdout] 1896 |                           let output: bool = <::glam::Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 1897 | |                             ::glam::Vec3,
[INFO] [stdout] 1898 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 1899 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1898 -                         >>::eq(&_self, &other)
[INFO] [stdout] 1899 -                             .into();
[INFO] [stdout] 1898 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1896 ~                         let output: bool = <bool as Into<_>>::into(<::glam::Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 1897 |                             ::glam::Vec3,
[INFO] [stdout] 1898 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u64>`
[INFO] [stdout]      --> src/lib.rs:18140:67
[INFO] [stdout]       |
[INFO] [stdout] 18140 |                           let output: ::core::option::Option<u64> = ::glam::I64Vec3::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 18141 | |                                 _self.into_inner(),
[INFO] [stdout] 18142 | |                                 rhs.into_inner(),
[INFO] [stdout] 18143 | |                             )
[INFO] [stdout] 18144 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18143 -                             )
[INFO] [stdout] 18144 -                             .into();
[INFO] [stdout] 18143 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18140 ~                         let output: ::core::option::Option<u64> = <std::option::Option<u64> as Into<_>>::into(::glam::I64Vec3::checked_manhattan_distance(
[INFO] [stdout] 18141 |                                 _self.into_inner(),
[INFO] [stdout] 18142 |                                 rhs.into_inner(),
[INFO] [stdout] 18143 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2047:44
[INFO] [stdout]      |
[INFO] [stdout] 2047 |                           let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2048 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2047 -                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout] 2048 -                             .into();
[INFO] [stdout] 2047 +                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2047 -                         let output: bool = ::glam::Vec3::is_finite(_self.into_inner())
[INFO] [stdout] 2048 -                             .into();
[INFO] [stdout] 2047 +                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_finite(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:18324:43
[INFO] [stdout]       |
[INFO] [stdout] 18324 |                           let output: i64 = ::glam::I64Vec3::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18325 | |                                 _self.into_inner(),
[INFO] [stdout] 18326 | |                                 rhs.into_inner(),
[INFO] [stdout] 18327 | |                             )
[INFO] [stdout] 18328 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18327 -                             )
[INFO] [stdout] 18328 -                             .into();
[INFO] [stdout] 18327 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18324 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec3::distance_squared(
[INFO] [stdout] 18325 |                                 _self.into_inner(),
[INFO] [stdout] 18326 |                                 rhs.into_inner(),
[INFO] [stdout] 18327 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2079:44
[INFO] [stdout]      |
[INFO] [stdout] 2079 |                           let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2080 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2079 -                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout] 2080 -                             .into();
[INFO] [stdout] 2079 +                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2079 -                         let output: bool = ::glam::Vec3::is_nan(_self.into_inner())
[INFO] [stdout] 2080 -                             .into();
[INFO] [stdout] 2079 +                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_nan(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:18411:43
[INFO] [stdout]       |
[INFO] [stdout] 18411 |                           let output: i64 = ::glam::I64Vec3::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18412 | |                                 _self.into_inner(),
[INFO] [stdout] 18413 | |                                 rhs.into_inner(),
[INFO] [stdout] 18414 | |                             )
[INFO] [stdout] 18415 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18414 -                             )
[INFO] [stdout] 18415 -                             .into();
[INFO] [stdout] 18414 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18411 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec3::dot(
[INFO] [stdout] 18412 |                                 _self.into_inner(),
[INFO] [stdout] 18413 |                                 rhs.into_inner(),
[INFO] [stdout] 18414 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:2111:43
[INFO] [stdout]      |
[INFO] [stdout] 2111 |                           let output: u32 = ::glam::Vec3::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2112 | |                                 _self.into_inner(),
[INFO] [stdout] 2113 | |                             )
[INFO] [stdout] 2114 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2113 -                             )
[INFO] [stdout] 2114 -                             .into();
[INFO] [stdout] 2113 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2111 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::Vec3::is_negative_bitmask(
[INFO] [stdout] 2112 |                                 _self.into_inner(),
[INFO] [stdout] 2113 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:18447:43
[INFO] [stdout]       |
[INFO] [stdout] 18447 |                           let output: i64 = ::glam::I64Vec3::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18448 | |                                 _self.into_inner(),
[INFO] [stdout] 18449 | |                             )
[INFO] [stdout] 18450 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18449 -                             )
[INFO] [stdout] 18450 -                             .into();
[INFO] [stdout] 18449 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18447 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec3::element_product(
[INFO] [stdout] 18448 |                                 _self.into_inner(),
[INFO] [stdout] 18449 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:2145:44
[INFO] [stdout]      |
[INFO] [stdout] 2145 |                           let output: bool = ::glam::Vec3::is_normalized(
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 2146 | |                                 _self.into_inner(),
[INFO] [stdout] 2147 | |                             )
[INFO] [stdout] 2148 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2147 -                             )
[INFO] [stdout] 2148 -                             .into();
[INFO] [stdout] 2147 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2145 ~                         let output: bool = <bool as Into<_>>::into(::glam::Vec3::is_normalized(
[INFO] [stdout] 2146 |                                 _self.into_inner(),
[INFO] [stdout] 2147 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:18464:43
[INFO] [stdout]       |
[INFO] [stdout] 18464 |                           let output: i64 = ::glam::I64Vec3::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18465 | |                                 _self.into_inner(),
[INFO] [stdout] 18466 | |                             )
[INFO] [stdout] 18467 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18466 -                             )
[INFO] [stdout] 18467 -                             .into();
[INFO] [stdout] 18466 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18464 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec3::element_sum(
[INFO] [stdout] 18465 |                                 _self.into_inner(),
[INFO] [stdout] 18466 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2162:43
[INFO] [stdout]      |
[INFO] [stdout] 2162 |                           let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2163 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2162 -                         let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout] 2163 -                             .into();
[INFO] [stdout] 2162 +                         let output: f32 = ::glam::Vec3::length(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2162 -                         let output: f32 = ::glam::Vec3::length(_self.into_inner())
[INFO] [stdout] 2163 -                             .into();
[INFO] [stdout] 2162 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:18481:44
[INFO] [stdout]       |
[INFO] [stdout] 18481 |                           let output: bool = <::glam::I64Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 18482 | |                             ::glam::I64Vec3,
[INFO] [stdout] 18483 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 18484 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18483 -                         >>::eq(&_self, &other)
[INFO] [stdout] 18484 -                             .into();
[INFO] [stdout] 18483 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18481 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I64Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 18482 |                             ::glam::I64Vec3,
[INFO] [stdout] 18483 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2177:43
[INFO] [stdout]      |
[INFO] [stdout] 2177 |                           let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2178 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2177 -                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout] 2178 -                             .into();
[INFO] [stdout] 2177 +                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2177 -                         let output: f32 = ::glam::Vec3::length_recip(_self.into_inner())
[INFO] [stdout] 2178 -                             .into();
[INFO] [stdout] 2177 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length_recip(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:18531:43
[INFO] [stdout]       |
[INFO] [stdout] 18531 |                           let output: u32 = ::glam::I64Vec3::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18532 | |                                 _self.into_inner(),
[INFO] [stdout] 18533 | |                             )
[INFO] [stdout] 18534 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18533 -                             )
[INFO] [stdout] 18534 -                             .into();
[INFO] [stdout] 18533 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18531 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I64Vec3::is_negative_bitmask(
[INFO] [stdout] 18532 |                                 _self.into_inner(),
[INFO] [stdout] 18533 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2192:43
[INFO] [stdout]      |
[INFO] [stdout] 2192 |                           let output: f32 = ::glam::Vec3::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2193 | |                                 _self.into_inner(),
[INFO] [stdout] 2194 | |                             )
[INFO] [stdout] 2195 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2194 -                             )
[INFO] [stdout] 2195 -                             .into();
[INFO] [stdout] 2194 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2192 ~                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::length_squared(
[INFO] [stdout] 2193 |                                 _self.into_inner(),
[INFO] [stdout] 2194 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:18565:43
[INFO] [stdout]       |
[INFO] [stdout] 18565 |                           let output: i64 = ::glam::I64Vec3::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18566 | |                                 _self.into_inner(),
[INFO] [stdout] 18567 | |                             )
[INFO] [stdout] 18568 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18567 -                             )
[INFO] [stdout] 18568 -                             .into();
[INFO] [stdout] 18567 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18565 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec3::length_squared(
[INFO] [stdout] 18566 |                                 _self.into_inner(),
[INFO] [stdout] 18567 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/lib.rs:18582:43
[INFO] [stdout]       |
[INFO] [stdout] 18582 |                           let output: u64 = ::glam::I64Vec3::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18583 | |                                 _self.into_inner(),
[INFO] [stdout] 18584 | |                                 rhs.into_inner(),
[INFO] [stdout] 18585 | |                             )
[INFO] [stdout] 18586 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18585 -                             )
[INFO] [stdout] 18586 -                             .into();
[INFO] [stdout] 18585 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18582 ~                         let output: u64 = <u64 as Into<_>>::into(::glam::I64Vec3::manhattan_distance(
[INFO] [stdout] 18583 |                                 _self.into_inner(),
[INFO] [stdout] 18584 |                                 rhs.into_inner(),
[INFO] [stdout] 18585 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2299:43
[INFO] [stdout]      |
[INFO] [stdout] 2299 |                           let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2300 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2299 -                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout] 2300 -                             .into();
[INFO] [stdout] 2299 +                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2299 -                         let output: f32 = ::glam::Vec3::max_element(_self.into_inner())
[INFO] [stdout] 2300 -                             .into();
[INFO] [stdout] 2299 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:18618:43
[INFO] [stdout]       |
[INFO] [stdout] 18618 |                           let output: i64 = ::glam::I64Vec3::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18619 | |                                 _self.into_inner(),
[INFO] [stdout] 18620 | |                             )
[INFO] [stdout] 18621 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18620 -                             )
[INFO] [stdout] 18621 -                             .into();
[INFO] [stdout] 18620 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18618 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec3::max_element(
[INFO] [stdout] 18619 |                                 _self.into_inner(),
[INFO] [stdout] 18620 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:2314:45
[INFO] [stdout]      |
[INFO] [stdout] 2314 |                           let output: usize = ::glam::Vec3::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 2315 | |                                 _self.into_inner(),
[INFO] [stdout] 2316 | |                             )
[INFO] [stdout] 2317 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2316 -                             )
[INFO] [stdout] 2317 -                             .into();
[INFO] [stdout] 2316 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2314 ~                         let output: usize = <usize as Into<_>>::into(::glam::Vec3::max_position(
[INFO] [stdout] 2315 |                                 _self.into_inner(),
[INFO] [stdout] 2316 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:2367:43
[INFO] [stdout]      |
[INFO] [stdout] 2367 |                           let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 2368 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2367 -                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout] 2368 -                             .into();
[INFO] [stdout] 2367 +                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2367 -                         let output: f32 = ::glam::Vec3::min_element(_self.into_inner())
[INFO] [stdout] 2368 -                             .into();
[INFO] [stdout] 2367 +                         let output: f32 = <f32 as Into<_>>::into(::glam::Vec3::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:2382:45
[INFO] [stdout]      |
[INFO] [stdout] 2382 |                           let output: usize = ::glam::Vec3::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 2383 | |                                 _self.into_inner(),
[INFO] [stdout] 2384 | |                             )
[INFO] [stdout] 2385 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2384 -                             )
[INFO] [stdout] 2385 -                             .into();
[INFO] [stdout] 2384 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2382 ~                         let output: usize = <usize as Into<_>>::into(::glam::Vec3::min_position(
[INFO] [stdout] 2383 |                                 _self.into_inner(),
[INFO] [stdout] 2384 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[f32; 3]`
[INFO] [stdout]     --> src/lib.rs:3105:48
[INFO] [stdout]      |
[INFO] [stdout] 3105 |                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3105 -                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout] 3105 +                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3105 -                         let output: [f32; 3] = ::glam::Vec3::to_array(&_self).into();
[INFO] [stdout] 3105 +                         let output: [f32; 3] = <[f32; 3] as Into<_>>::into(::glam::Vec3::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:18635:45
[INFO] [stdout]       |
[INFO] [stdout] 18635 |                           let output: usize = ::glam::I64Vec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 18636 | |                                 _self.into_inner(),
[INFO] [stdout] 18637 | |                             )
[INFO] [stdout] 18638 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18637 -                             )
[INFO] [stdout] 18638 -                             .into();
[INFO] [stdout] 18637 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18635 ~                         let output: usize = <usize as Into<_>>::into(::glam::I64Vec3::max_position(
[INFO] [stdout] 18636 |                                 _self.into_inner(),
[INFO] [stdout] 18637 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:18670:43
[INFO] [stdout]       |
[INFO] [stdout] 18670 |                           let output: i64 = ::glam::I64Vec3::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 18671 | |                                 _self.into_inner(),
[INFO] [stdout] 18672 | |                             )
[INFO] [stdout] 18673 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18672 -                             )
[INFO] [stdout] 18673 -                             .into();
[INFO] [stdout] 18672 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18670 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec3::min_element(
[INFO] [stdout] 18671 |                                 _self.into_inner(),
[INFO] [stdout] 18672 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:18687:45
[INFO] [stdout]       |
[INFO] [stdout] 18687 |                           let output: usize = ::glam::I64Vec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 18688 | |                                 _self.into_inner(),
[INFO] [stdout] 18689 | |                             )
[INFO] [stdout] 18690 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18689 -                             )
[INFO] [stdout] 18690 -                             .into();
[INFO] [stdout] 18689 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18687 ~                         let output: usize = <usize as Into<_>>::into(::glam::I64Vec3::min_position(
[INFO] [stdout] 18688 |                                 _self.into_inner(),
[INFO] [stdout] 18689 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3265:40
[INFO] [stdout]      |
[INFO] [stdout] 3265 |                       let output: bool = <::bevy_reflect::OffsetAccess as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ________________________________________^
[INFO] [stdout] 3266 | |                         ::bevy_reflect::OffsetAccess,
[INFO] [stdout] 3267 | |                     >>::eq(&_self, &other)
[INFO] [stdout] 3268 | |                     .into();
[INFO] [stdout]      | |___________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3267 -                     >>::eq(&_self, &other)
[INFO] [stdout] 3268 -                     .into();
[INFO] [stdout] 3267 +                     >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3265 ~                     let output: bool = <bool as Into<_>>::into(<::bevy_reflect::OffsetAccess as ::core::cmp::PartialEq<
[INFO] [stdout] 3266 |                         ::bevy_reflect::OffsetAccess,
[INFO] [stdout] 3267 ~                     >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i64; 3]`
[INFO] [stdout]      --> src/lib.rs:19070:48
[INFO] [stdout]       |
[INFO] [stdout] 19070 |                         let output: [i64; 3] = ::glam::I64Vec3::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19070 -                         let output: [i64; 3] = ::glam::I64Vec3::to_array(&_self).into();
[INFO] [stdout] 19070 +                         let output: [i64; 3] = ::glam::I64Vec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19070 -                         let output: [i64; 3] = ::glam::I64Vec3::to_array(&_self).into();
[INFO] [stdout] 19070 +                         let output: [i64; 3] = <[i64; 3] as Into<_>>::into(::glam::I64Vec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/lib.rs:19492:43
[INFO] [stdout]       |
[INFO] [stdout] 19492 |                           let output: u64 = ::glam::I64Vec4::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19493 | |                                 _self.into_inner(),
[INFO] [stdout] 19494 | |                                 rhs.into_inner(),
[INFO] [stdout] 19495 | |                             )
[INFO] [stdout] 19496 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19495 -                             )
[INFO] [stdout] 19496 -                             .into();
[INFO] [stdout] 19495 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19492 ~                         let output: u64 = <u64 as Into<_>>::into(::glam::I64Vec4::chebyshev_distance(
[INFO] [stdout] 19493 |                                 _self.into_inner(),
[INFO] [stdout] 19494 |                                 rhs.into_inner(),
[INFO] [stdout] 19495 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u64>`
[INFO] [stdout]      --> src/lib.rs:19510:67
[INFO] [stdout]       |
[INFO] [stdout] 19510 |                           let output: ::core::option::Option<u64> = ::glam::I64Vec4::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 19511 | |                                 _self.into_inner(),
[INFO] [stdout] 19512 | |                                 rhs.into_inner(),
[INFO] [stdout] 19513 | |                             )
[INFO] [stdout] 19514 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19513 -                             )
[INFO] [stdout] 19514 -                             .into();
[INFO] [stdout] 19513 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19510 ~                         let output: ::core::option::Option<u64> = <std::option::Option<u64> as Into<_>>::into(::glam::I64Vec4::checked_manhattan_distance(
[INFO] [stdout] 19511 |                                 _self.into_inner(),
[INFO] [stdout] 19512 |                                 rhs.into_inner(),
[INFO] [stdout] 19513 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3326:44
[INFO] [stdout]      |
[INFO] [stdout] 3326 |                           let output: bool = <::bevy_reflect::ParsedPath as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3327 | |                             ::bevy_reflect::ParsedPath,
[INFO] [stdout] 3328 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3329 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3328 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3329 -                             .into();
[INFO] [stdout] 3328 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3326 ~                         let output: bool = <bool as Into<_>>::into(<::bevy_reflect::ParsedPath as ::core::cmp::PartialEq<
[INFO] [stdout] 3327 |                             ::bevy_reflect::ParsedPath,
[INFO] [stdout] 3328 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:19676:43
[INFO] [stdout]       |
[INFO] [stdout] 19676 |                           let output: i64 = ::glam::I64Vec4::distance_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19677 | |                                 _self.into_inner(),
[INFO] [stdout] 19678 | |                                 rhs.into_inner(),
[INFO] [stdout] 19679 | |                             )
[INFO] [stdout] 19680 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19679 -                             )
[INFO] [stdout] 19680 -                             .into();
[INFO] [stdout] 19679 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19676 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec4::distance_squared(
[INFO] [stdout] 19677 |                                 _self.into_inner(),
[INFO] [stdout] 19678 |                                 rhs.into_inner(),
[INFO] [stdout] 19679 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3442:44
[INFO] [stdout]      |
[INFO] [stdout] 3442 |                           let output: bool = <::std::time::Instant as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3443 | |                             ::std::time::Instant,
[INFO] [stdout] 3444 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3445 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3444 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3445 -                             .into();
[INFO] [stdout] 3444 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3442 ~                         let output: bool = <bool as Into<_>>::into(<::std::time::Instant as ::core::cmp::PartialEq<
[INFO] [stdout] 3443 |                             ::std::time::Instant,
[INFO] [stdout] 3444 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:19763:43
[INFO] [stdout]       |
[INFO] [stdout] 19763 |                           let output: i64 = ::glam::I64Vec4::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19764 | |                                 _self.into_inner(),
[INFO] [stdout] 19765 | |                                 rhs.into_inner(),
[INFO] [stdout] 19766 | |                             )
[INFO] [stdout] 19767 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19766 -                             )
[INFO] [stdout] 19767 -                             .into();
[INFO] [stdout] 19766 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19763 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec4::dot(
[INFO] [stdout] 19764 |                                 _self.into_inner(),
[INFO] [stdout] 19765 |                                 rhs.into_inner(),
[INFO] [stdout] 19766 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3552:44
[INFO] [stdout]      |
[INFO] [stdout] 3552 |                           let output: bool = <::core::net::SocketAddr as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3553 | |                             ::core::net::SocketAddr,
[INFO] [stdout] 3554 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3555 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3554 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3555 -                             .into();
[INFO] [stdout] 3554 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3552 ~                         let output: bool = <bool as Into<_>>::into(<::core::net::SocketAddr as ::core::cmp::PartialEq<
[INFO] [stdout] 3553 |                             ::core::net::SocketAddr,
[INFO] [stdout] 3554 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:19799:43
[INFO] [stdout]       |
[INFO] [stdout] 19799 |                           let output: i64 = ::glam::I64Vec4::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19800 | |                                 _self.into_inner(),
[INFO] [stdout] 19801 | |                             )
[INFO] [stdout] 19802 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19801 -                             )
[INFO] [stdout] 19802 -                             .into();
[INFO] [stdout] 19801 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19799 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec4::element_product(
[INFO] [stdout] 19800 |                                 _self.into_inner(),
[INFO] [stdout] 19801 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3569:44
[INFO] [stdout]      |
[INFO] [stdout] 3569 |                           let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3570 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3569 -                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout] 3570 -                             .into();
[INFO] [stdout] 3569 +                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3569 -                         let output: bool = ::core::net::SocketAddr::is_ipv4(&_self)
[INFO] [stdout] 3570 -                             .into();
[INFO] [stdout] 3569 +                         let output: bool = <bool as Into<_>>::into(::core::net::SocketAddr::is_ipv4(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:19816:43
[INFO] [stdout]       |
[INFO] [stdout] 19816 |                           let output: i64 = ::glam::I64Vec4::element_sum(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19817 | |                                 _self.into_inner(),
[INFO] [stdout] 19818 | |                             )
[INFO] [stdout] 19819 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19818 -                             )
[INFO] [stdout] 19819 -                             .into();
[INFO] [stdout] 19818 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19816 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec4::element_sum(
[INFO] [stdout] 19817 |                                 _self.into_inner(),
[INFO] [stdout] 19818 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3584:44
[INFO] [stdout]      |
[INFO] [stdout] 3584 |                           let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3585 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3584 -                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout] 3585 -                             .into();
[INFO] [stdout] 3584 +                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3584 -                         let output: bool = ::core::net::SocketAddr::is_ipv6(&_self)
[INFO] [stdout] 3585 -                             .into();
[INFO] [stdout] 3584 +                         let output: bool = <bool as Into<_>>::into(::core::net::SocketAddr::is_ipv6(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:19833:44
[INFO] [stdout]       |
[INFO] [stdout] 19833 |                           let output: bool = <::glam::I64Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 19834 | |                             ::glam::I64Vec4,
[INFO] [stdout] 19835 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 19836 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19835 -                         >>::eq(&_self, &other)
[INFO] [stdout] 19836 -                             .into();
[INFO] [stdout] 19835 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19833 ~                         let output: bool = <bool as Into<_>>::into(<::glam::I64Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 19834 |                             ::glam::I64Vec4,
[INFO] [stdout] 19835 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/lib.rs:3599:43
[INFO] [stdout]      |
[INFO] [stdout] 3599 |                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3599 -                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout] 3599 +                         let output: u16 = ::core::net::SocketAddr::port(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3599 -                         let output: u16 = ::core::net::SocketAddr::port(&_self).into();
[INFO] [stdout] 3599 +                         let output: u16 = <u16 as Into<_>>::into(::core::net::SocketAddr::port(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:19865:43
[INFO] [stdout]       |
[INFO] [stdout] 19865 |                           let output: u32 = ::glam::I64Vec4::is_negative_bitmask(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19866 | |                                 _self.into_inner(),
[INFO] [stdout] 19867 | |                             )
[INFO] [stdout] 19868 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19867 -                             )
[INFO] [stdout] 19868 -                             .into();
[INFO] [stdout] 19867 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19865 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::I64Vec4::is_negative_bitmask(
[INFO] [stdout] 19866 |                                 _self.into_inner(),
[INFO] [stdout] 19867 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]     --> src/lib.rs:3613:42
[INFO] [stdout]      |
[INFO] [stdout] 3613 |                           let output: () = ::core::net::SocketAddr::set_port(
[INFO] [stdout]      |  __________________________________________^
[INFO] [stdout] 3614 | |                                 &mut _self,
[INFO] [stdout] 3615 | |                                 new_port,
[INFO] [stdout] 3616 | |                             )
[INFO] [stdout] 3617 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3616 -                             )
[INFO] [stdout] 3617 -                             .into();
[INFO] [stdout] 3616 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3613 ~                         let output: () = <() as Into<_>>::into(::core::net::SocketAddr::set_port(
[INFO] [stdout] 3614 |                                 &mut _self,
[INFO] [stdout] 3615 |                                 new_port,
[INFO] [stdout] 3616 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3678:44
[INFO] [stdout]      |
[INFO] [stdout] 3678 |                           let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3679 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3678 -                         let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout] 3679 -                             .into();
[INFO] [stdout] 3678 +                         let output: u128 = ::core::time::Duration::as_micros(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3678 -                         let output: u128 = ::core::time::Duration::as_micros(&_self)
[INFO] [stdout] 3679 -                             .into();
[INFO] [stdout] 3678 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_micros(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3693:44
[INFO] [stdout]      |
[INFO] [stdout] 3693 |                           let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3694 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3693 -                         let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout] 3694 -                             .into();
[INFO] [stdout] 3693 +                         let output: u128 = ::core::time::Duration::as_millis(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3693 -                         let output: u128 = ::core::time::Duration::as_millis(&_self)
[INFO] [stdout] 3694 -                             .into();
[INFO] [stdout] 3693 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_millis(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u128`
[INFO] [stdout]     --> src/lib.rs:3708:44
[INFO] [stdout]      |
[INFO] [stdout] 3708 |                           let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3709 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3708 -                         let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout] 3709 -                             .into();
[INFO] [stdout] 3708 +                         let output: u128 = ::core::time::Duration::as_nanos(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3708 -                         let output: u128 = ::core::time::Duration::as_nanos(&_self)
[INFO] [stdout] 3709 -                             .into();
[INFO] [stdout] 3708 +                         let output: u128 = <u128 as Into<_>>::into(::core::time::Duration::as_nanos(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:19899:43
[INFO] [stdout]       |
[INFO] [stdout] 19899 |                           let output: i64 = ::glam::I64Vec4::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19900 | |                                 _self.into_inner(),
[INFO] [stdout] 19901 | |                             )
[INFO] [stdout] 19902 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19901 -                             )
[INFO] [stdout] 19902 -                             .into();
[INFO] [stdout] 19901 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19899 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec4::length_squared(
[INFO] [stdout] 19900 |                                 _self.into_inner(),
[INFO] [stdout] 19901 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/lib.rs:3723:43
[INFO] [stdout]      |
[INFO] [stdout] 3723 |                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3723 -                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout] 3723 +                         let output: u64 = ::core::time::Duration::as_secs(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3723 -                         let output: u64 = ::core::time::Duration::as_secs(&_self).into();
[INFO] [stdout] 3723 +                         let output: u64 = <u64 as Into<_>>::into(::core::time::Duration::as_secs(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]      --> src/lib.rs:19916:43
[INFO] [stdout]       |
[INFO] [stdout] 19916 |                           let output: u64 = ::glam::I64Vec4::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19917 | |                                 _self.into_inner(),
[INFO] [stdout] 19918 | |                                 rhs.into_inner(),
[INFO] [stdout] 19919 | |                             )
[INFO] [stdout] 19920 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19919 -                             )
[INFO] [stdout] 19920 -                             .into();
[INFO] [stdout] 19919 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19916 ~                         let output: u64 = <u64 as Into<_>>::into(::glam::I64Vec4::manhattan_distance(
[INFO] [stdout] 19917 |                                 _self.into_inner(),
[INFO] [stdout] 19918 |                                 rhs.into_inner(),
[INFO] [stdout] 19919 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:19952:43
[INFO] [stdout]       |
[INFO] [stdout] 19952 |                           let output: i64 = ::glam::I64Vec4::max_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 19953 | |                                 _self.into_inner(),
[INFO] [stdout] 19954 | |                             )
[INFO] [stdout] 19955 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19954 -                             )
[INFO] [stdout] 19955 -                             .into();
[INFO] [stdout] 19954 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19952 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec4::max_element(
[INFO] [stdout] 19953 |                                 _self.into_inner(),
[INFO] [stdout] 19954 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:19969:45
[INFO] [stdout]       |
[INFO] [stdout] 19969 |                           let output: usize = ::glam::I64Vec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 19970 | |                                 _self.into_inner(),
[INFO] [stdout] 19971 | |                             )
[INFO] [stdout] 19972 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19971 -                             )
[INFO] [stdout] 19972 -                             .into();
[INFO] [stdout] 19971 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19969 ~                         let output: usize = <usize as Into<_>>::into(::glam::I64Vec4::max_position(
[INFO] [stdout] 19970 |                                 _self.into_inner(),
[INFO] [stdout] 19971 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:3737:43
[INFO] [stdout]      |
[INFO] [stdout] 3737 |                           let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3738 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3737 -                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout] 3738 -                             .into();
[INFO] [stdout] 3737 +                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3737 -                         let output: f32 = ::core::time::Duration::as_secs_f32(&_self)
[INFO] [stdout] 3738 -                             .into();
[INFO] [stdout] 3737 +                         let output: f32 = <f32 as Into<_>>::into(::core::time::Duration::as_secs_f32(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]      --> src/lib.rs:20004:43
[INFO] [stdout]       |
[INFO] [stdout] 20004 |                           let output: i64 = ::glam::I64Vec4::min_element(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 20005 | |                                 _self.into_inner(),
[INFO] [stdout] 20006 | |                             )
[INFO] [stdout] 20007 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 20006 -                             )
[INFO] [stdout] 20007 -                             .into();
[INFO] [stdout] 20006 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 20004 ~                         let output: i64 = <i64 as Into<_>>::into(::glam::I64Vec4::min_element(
[INFO] [stdout] 20005 |                                 _self.into_inner(),
[INFO] [stdout] 20006 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:20021:45
[INFO] [stdout]       |
[INFO] [stdout] 20021 |                           let output: usize = ::glam::I64Vec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 20022 | |                                 _self.into_inner(),
[INFO] [stdout] 20023 | |                             )
[INFO] [stdout] 20024 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 20023 -                             )
[INFO] [stdout] 20024 -                             .into();
[INFO] [stdout] 20023 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 20021 ~                         let output: usize = <usize as Into<_>>::into(::glam::I64Vec4::min_position(
[INFO] [stdout] 20022 |                                 _self.into_inner(),
[INFO] [stdout] 20023 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/lib.rs:3752:43
[INFO] [stdout]      |
[INFO] [stdout] 3752 |                           let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3753 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3752 -                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout] 3753 -                             .into();
[INFO] [stdout] 3752 +                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3752 -                         let output: f64 = ::core::time::Duration::as_secs_f64(&_self)
[INFO] [stdout] 3753 -                             .into();
[INFO] [stdout] 3752 +                         let output: f64 = <f64 as Into<_>>::into(::core::time::Duration::as_secs_f64(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i64; 4]`
[INFO] [stdout]      --> src/lib.rs:20404:48
[INFO] [stdout]       |
[INFO] [stdout] 20404 |                         let output: [i64; 4] = ::glam::I64Vec4::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 20404 -                         let output: [i64; 4] = ::glam::I64Vec4::to_array(&_self).into();
[INFO] [stdout] 20404 +                         let output: [i64; 4] = ::glam::I64Vec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 20404 -                         let output: [i64; 4] = ::glam::I64Vec4::to_array(&_self).into();
[INFO] [stdout] 20404 +                         let output: [i64; 4] = <[i64; 4] as Into<_>>::into(::glam::I64Vec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/lib.rs:3801:43
[INFO] [stdout]      |
[INFO] [stdout] 3801 |                           let output: f32 = ::core::time::Duration::div_duration_f32(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3802 | |                                 _self.into_inner(),
[INFO] [stdout] 3803 | |                                 rhs.into_inner(),
[INFO] [stdout] 3804 | |                             )
[INFO] [stdout] 3805 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3804 -                             )
[INFO] [stdout] 3805 -                             .into();
[INFO] [stdout] 3804 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3801 ~                         let output: f32 = <f32 as Into<_>>::into(::core::time::Duration::div_duration_f32(
[INFO] [stdout] 3802 |                                 _self.into_inner(),
[INFO] [stdout] 3803 |                                 rhs.into_inner(),
[INFO] [stdout] 3804 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:20827:43
[INFO] [stdout]       |
[INFO] [stdout] 20827 |                           let output: u32 = ::glam::UVec2::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 20828 | |                                 _self.into_inner(),
[INFO] [stdout] 20829 | |                                 rhs.into_inner(),
[INFO] [stdout] 20830 | |                             )
[INFO] [stdout] 20831 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 20830 -                             )
[INFO] [stdout] 20831 -                             .into();
[INFO] [stdout] 20830 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 20827 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec2::chebyshev_distance(
[INFO] [stdout] 20828 |                                 _self.into_inner(),
[INFO] [stdout] 20829 |                                 rhs.into_inner(),
[INFO] [stdout] 20830 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/lib.rs:3819:43
[INFO] [stdout]      |
[INFO] [stdout] 3819 |                           let output: f64 = ::core::time::Duration::div_duration_f64(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 3820 | |                                 _self.into_inner(),
[INFO] [stdout] 3821 | |                                 rhs.into_inner(),
[INFO] [stdout] 3822 | |                             )
[INFO] [stdout] 3823 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3822 -                             )
[INFO] [stdout] 3823 -                             .into();
[INFO] [stdout] 3822 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3819 ~                         let output: f64 = <f64 as Into<_>>::into(::core::time::Duration::div_duration_f64(
[INFO] [stdout] 3820 |                                 _self.into_inner(),
[INFO] [stdout] 3821 |                                 rhs.into_inner(),
[INFO] [stdout] 3822 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]      --> src/lib.rs:20845:67
[INFO] [stdout]       |
[INFO] [stdout] 20845 |                           let output: ::core::option::Option<u32> = ::glam::UVec2::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 20846 | |                                 _self.into_inner(),
[INFO] [stdout] 20847 | |                                 rhs.into_inner(),
[INFO] [stdout] 20848 | |                             )
[INFO] [stdout] 20849 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 20848 -                             )
[INFO] [stdout] 20849 -                             .into();
[INFO] [stdout] 20848 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 20845 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::UVec2::checked_manhattan_distance(
[INFO] [stdout] 20846 |                                 _self.into_inner(),
[INFO] [stdout] 20847 |                                 rhs.into_inner(),
[INFO] [stdout] 20848 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:3873:44
[INFO] [stdout]      |
[INFO] [stdout] 3873 |                           let output: bool = <::core::time::Duration as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 3874 | |                             ::core::time::Duration,
[INFO] [stdout] 3875 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 3876 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3875 -                         >>::eq(&_self, &other)
[INFO] [stdout] 3876 -                             .into();
[INFO] [stdout] 3875 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3873 ~                         let output: bool = <bool as Into<_>>::into(<::core::time::Duration as ::core::cmp::PartialEq<
[INFO] [stdout] 3874 |                             ::core::time::Duration,
[INFO] [stdout] 3875 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:21058:43
[INFO] [stdout]       |
[INFO] [stdout] 21058 |                           let output: u32 = ::glam::UVec2::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 21059 | |                                 _self.into_inner(),
[INFO] [stdout] 21060 | |                                 rhs.into_inner(),
[INFO] [stdout] 21061 | |                             )
[INFO] [stdout] 21062 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21061 -                             )
[INFO] [stdout] 21062 -                             .into();
[INFO] [stdout] 21061 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21058 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec2::dot(
[INFO] [stdout] 21059 |                                 _self.into_inner(),
[INFO] [stdout] 21060 |                                 rhs.into_inner(),
[INFO] [stdout] 21061 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4043:44
[INFO] [stdout]      |
[INFO] [stdout] 4043 |                           let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4044 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4043 -                         let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout] 4044 -                             .into();
[INFO] [stdout] 4043 +                         let output: bool = ::core::time::Duration::is_zero(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4043 -                         let output: bool = ::core::time::Duration::is_zero(&_self)
[INFO] [stdout] 4044 -                             .into();
[INFO] [stdout] 4043 +                         let output: bool = <bool as Into<_>>::into(::core::time::Duration::is_zero(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4200:43
[INFO] [stdout]      |
[INFO] [stdout] 4200 |                           let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4201 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4200 -                         let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout] 4201 -                             .into();
[INFO] [stdout] 4200 +                         let output: u32 = ::core::time::Duration::subsec_micros(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4200 -                         let output: u32 = ::core::time::Duration::subsec_micros(&_self)
[INFO] [stdout] 4201 -                             .into();
[INFO] [stdout] 4200 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_micros(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4215:43
[INFO] [stdout]      |
[INFO] [stdout] 4215 |                           let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4216 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4215 -                         let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout] 4216 -                             .into();
[INFO] [stdout] 4215 +                         let output: u32 = ::core::time::Duration::subsec_millis(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4215 -                         let output: u32 = ::core::time::Duration::subsec_millis(&_self)
[INFO] [stdout] 4216 -                             .into();
[INFO] [stdout] 4215 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_millis(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:21094:43
[INFO] [stdout]       |
[INFO] [stdout] 21094 |                           let output: u32 = ::glam::UVec2::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 21095 | |                                 _self.into_inner(),
[INFO] [stdout] 21096 | |                             )
[INFO] [stdout] 21097 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21096 -                             )
[INFO] [stdout] 21097 -                             .into();
[INFO] [stdout] 21096 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21094 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec2::element_product(
[INFO] [stdout] 21095 |                                 _self.into_inner(),
[INFO] [stdout] 21096 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:21111:43
[INFO] [stdout]       |
[INFO] [stdout] 21111 |                           let output: u32 = ::glam::UVec2::element_sum(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 21112 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21111 -                         let output: u32 = ::glam::UVec2::element_sum(_self.into_inner())
[INFO] [stdout] 21112 -                             .into();
[INFO] [stdout] 21111 +                         let output: u32 = ::glam::UVec2::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21111 -                         let output: u32 = ::glam::UVec2::element_sum(_self.into_inner())
[INFO] [stdout] 21112 -                             .into();
[INFO] [stdout] 21111 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec2::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4230:43
[INFO] [stdout]      |
[INFO] [stdout] 4230 |                           let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4231 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4230 -                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout] 4231 -                             .into();
[INFO] [stdout] 4230 +                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4230 -                         let output: u32 = ::core::time::Duration::subsec_nanos(&_self)
[INFO] [stdout] 4231 -                             .into();
[INFO] [stdout] 4230 +                         let output: u32 = <u32 as Into<_>>::into(::core::time::Duration::subsec_nanos(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:21126:44
[INFO] [stdout]       |
[INFO] [stdout] 21126 |                           let output: bool = <::glam::UVec2 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 21127 | |                             ::glam::UVec2,
[INFO] [stdout] 21128 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 21129 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21128 -                         >>::eq(&_self, &other)
[INFO] [stdout] 21129 -                             .into();
[INFO] [stdout] 21128 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21126 ~                         let output: bool = <bool as Into<_>>::into(<::glam::UVec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 21127 |                             ::glam::UVec2,
[INFO] [stdout] 21128 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4476:43
[INFO] [stdout]      |
[INFO] [stdout] 4476 |                           let output: u32 = ::glam::IVec2::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4477 | |                                 _self.into_inner(),
[INFO] [stdout] 4478 | |                                 rhs.into_inner(),
[INFO] [stdout] 4479 | |                             )
[INFO] [stdout] 4480 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4479 -                             )
[INFO] [stdout] 4480 -                             .into();
[INFO] [stdout] 4479 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4476 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::chebyshev_distance(
[INFO] [stdout] 4477 |                                 _self.into_inner(),
[INFO] [stdout] 4478 |                                 rhs.into_inner(),
[INFO] [stdout] 4479 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:21176:43
[INFO] [stdout]       |
[INFO] [stdout] 21176 |                           let output: u32 = ::glam::UVec2::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 21177 | |                                 _self.into_inner(),
[INFO] [stdout] 21178 | |                             )
[INFO] [stdout] 21179 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21178 -                             )
[INFO] [stdout] 21179 -                             .into();
[INFO] [stdout] 21178 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21176 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec2::length_squared(
[INFO] [stdout] 21177 |                                 _self.into_inner(),
[INFO] [stdout] 21178 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:21193:43
[INFO] [stdout]       |
[INFO] [stdout] 21193 |                           let output: u32 = ::glam::UVec2::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 21194 | |                                 _self.into_inner(),
[INFO] [stdout] 21195 | |                                 rhs.into_inner(),
[INFO] [stdout] 21196 | |                             )
[INFO] [stdout] 21197 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21196 -                             )
[INFO] [stdout] 21197 -                             .into();
[INFO] [stdout] 21196 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21193 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec2::manhattan_distance(
[INFO] [stdout] 21194 |                                 _self.into_inner(),
[INFO] [stdout] 21195 |                                 rhs.into_inner(),
[INFO] [stdout] 21196 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:21229:43
[INFO] [stdout]       |
[INFO] [stdout] 21229 |                           let output: u32 = ::glam::UVec2::max_element(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 21230 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21229 -                         let output: u32 = ::glam::UVec2::max_element(_self.into_inner())
[INFO] [stdout] 21230 -                             .into();
[INFO] [stdout] 21229 +                         let output: u32 = ::glam::UVec2::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21229 -                         let output: u32 = ::glam::UVec2::max_element(_self.into_inner())
[INFO] [stdout] 21230 -                             .into();
[INFO] [stdout] 21229 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec2::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:21244:45
[INFO] [stdout]       |
[INFO] [stdout] 21244 |                           let output: usize = ::glam::UVec2::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 21245 | |                                 _self.into_inner(),
[INFO] [stdout] 21246 | |                             )
[INFO] [stdout] 21247 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21246 -                             )
[INFO] [stdout] 21247 -                             .into();
[INFO] [stdout] 21246 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21244 ~                         let output: usize = <usize as Into<_>>::into(::glam::UVec2::max_position(
[INFO] [stdout] 21245 |                                 _self.into_inner(),
[INFO] [stdout] 21246 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:21279:43
[INFO] [stdout]       |
[INFO] [stdout] 21279 |                           let output: u32 = ::glam::UVec2::min_element(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 21280 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21279 -                         let output: u32 = ::glam::UVec2::min_element(_self.into_inner())
[INFO] [stdout] 21280 -                             .into();
[INFO] [stdout] 21279 +                         let output: u32 = ::glam::UVec2::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21279 -                         let output: u32 = ::glam::UVec2::min_element(_self.into_inner())
[INFO] [stdout] 21280 -                             .into();
[INFO] [stdout] 21279 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec2::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:21294:45
[INFO] [stdout]       |
[INFO] [stdout] 21294 |                           let output: usize = ::glam::UVec2::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 21295 | |                                 _self.into_inner(),
[INFO] [stdout] 21296 | |                             )
[INFO] [stdout] 21297 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21296 -                             )
[INFO] [stdout] 21297 -                             .into();
[INFO] [stdout] 21296 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21294 ~                         let output: usize = <usize as Into<_>>::into(::glam::UVec2::min_position(
[INFO] [stdout] 21295 |                                 _self.into_inner(),
[INFO] [stdout] 21296 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u32; 2]`
[INFO] [stdout]      --> src/lib.rs:21605:48
[INFO] [stdout]       |
[INFO] [stdout] 21605 |                         let output: [u32; 2] = ::glam::UVec2::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21605 -                         let output: [u32; 2] = ::glam::UVec2::to_array(&_self).into();
[INFO] [stdout] 21605 +                         let output: [u32; 2] = ::glam::UVec2::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21605 -                         let output: [u32; 2] = ::glam::UVec2::to_array(&_self).into();
[INFO] [stdout] 21605 +                         let output: [u32; 2] = <[u32; 2] as Into<_>>::into(::glam::UVec2::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:21974:43
[INFO] [stdout]       |
[INFO] [stdout] 21974 |                           let output: u32 = ::glam::UVec3::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 21975 | |                                 _self.into_inner(),
[INFO] [stdout] 21976 | |                                 rhs.into_inner(),
[INFO] [stdout] 21977 | |                             )
[INFO] [stdout] 21978 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21977 -                             )
[INFO] [stdout] 21978 -                             .into();
[INFO] [stdout] 21977 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21974 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec3::chebyshev_distance(
[INFO] [stdout] 21975 |                                 _self.into_inner(),
[INFO] [stdout] 21976 |                                 rhs.into_inner(),
[INFO] [stdout] 21977 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]      --> src/lib.rs:21992:67
[INFO] [stdout]       |
[INFO] [stdout] 21992 |                           let output: ::core::option::Option<u32> = ::glam::UVec3::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 21993 | |                                 _self.into_inner(),
[INFO] [stdout] 21994 | |                                 rhs.into_inner(),
[INFO] [stdout] 21995 | |                             )
[INFO] [stdout] 21996 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 21995 -                             )
[INFO] [stdout] 21996 -                             .into();
[INFO] [stdout] 21995 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 21992 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::UVec3::checked_manhattan_distance(
[INFO] [stdout] 21993 |                                 _self.into_inner(),
[INFO] [stdout] 21994 |                                 rhs.into_inner(),
[INFO] [stdout] 21995 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:22223:43
[INFO] [stdout]       |
[INFO] [stdout] 22223 |                           let output: u32 = ::glam::UVec3::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 22224 | |                                 _self.into_inner(),
[INFO] [stdout] 22225 | |                                 rhs.into_inner(),
[INFO] [stdout] 22226 | |                             )
[INFO] [stdout] 22227 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22226 -                             )
[INFO] [stdout] 22227 -                             .into();
[INFO] [stdout] 22226 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22223 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec3::dot(
[INFO] [stdout] 22224 |                                 _self.into_inner(),
[INFO] [stdout] 22225 |                                 rhs.into_inner(),
[INFO] [stdout] 22226 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:22259:43
[INFO] [stdout]       |
[INFO] [stdout] 22259 |                           let output: u32 = ::glam::UVec3::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 22260 | |                                 _self.into_inner(),
[INFO] [stdout] 22261 | |                             )
[INFO] [stdout] 22262 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22261 -                             )
[INFO] [stdout] 22262 -                             .into();
[INFO] [stdout] 22261 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22259 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec3::element_product(
[INFO] [stdout] 22260 |                                 _self.into_inner(),
[INFO] [stdout] 22261 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:22276:43
[INFO] [stdout]       |
[INFO] [stdout] 22276 |                           let output: u32 = ::glam::UVec3::element_sum(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 22277 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22276 -                         let output: u32 = ::glam::UVec3::element_sum(_self.into_inner())
[INFO] [stdout] 22277 -                             .into();
[INFO] [stdout] 22276 +                         let output: u32 = ::glam::UVec3::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22276 -                         let output: u32 = ::glam::UVec3::element_sum(_self.into_inner())
[INFO] [stdout] 22277 -                             .into();
[INFO] [stdout] 22276 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec3::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:22291:44
[INFO] [stdout]       |
[INFO] [stdout] 22291 |                           let output: bool = <::glam::UVec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 22292 | |                             ::glam::UVec3,
[INFO] [stdout] 22293 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 22294 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22293 -                         >>::eq(&_self, &other)
[INFO] [stdout] 22294 -                             .into();
[INFO] [stdout] 22293 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22291 ~                         let output: bool = <bool as Into<_>>::into(<::glam::UVec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 22292 |                             ::glam::UVec3,
[INFO] [stdout] 22293 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:22341:43
[INFO] [stdout]       |
[INFO] [stdout] 22341 |                           let output: u32 = ::glam::UVec3::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 22342 | |                                 _self.into_inner(),
[INFO] [stdout] 22343 | |                             )
[INFO] [stdout] 22344 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22343 -                             )
[INFO] [stdout] 22344 -                             .into();
[INFO] [stdout] 22343 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22341 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec3::length_squared(
[INFO] [stdout] 22342 |                                 _self.into_inner(),
[INFO] [stdout] 22343 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:22358:43
[INFO] [stdout]       |
[INFO] [stdout] 22358 |                           let output: u32 = ::glam::UVec3::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 22359 | |                                 _self.into_inner(),
[INFO] [stdout] 22360 | |                                 rhs.into_inner(),
[INFO] [stdout] 22361 | |                             )
[INFO] [stdout] 22362 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22361 -                             )
[INFO] [stdout] 22362 -                             .into();
[INFO] [stdout] 22361 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22358 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec3::manhattan_distance(
[INFO] [stdout] 22359 |                                 _self.into_inner(),
[INFO] [stdout] 22360 |                                 rhs.into_inner(),
[INFO] [stdout] 22361 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:22394:43
[INFO] [stdout]       |
[INFO] [stdout] 22394 |                           let output: u32 = ::glam::UVec3::max_element(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 22395 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22394 -                         let output: u32 = ::glam::UVec3::max_element(_self.into_inner())
[INFO] [stdout] 22395 -                             .into();
[INFO] [stdout] 22394 +                         let output: u32 = ::glam::UVec3::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22394 -                         let output: u32 = ::glam::UVec3::max_element(_self.into_inner())
[INFO] [stdout] 22395 -                             .into();
[INFO] [stdout] 22394 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec3::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:22409:45
[INFO] [stdout]       |
[INFO] [stdout] 22409 |                           let output: usize = ::glam::UVec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 22410 | |                                 _self.into_inner(),
[INFO] [stdout] 22411 | |                             )
[INFO] [stdout] 22412 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22411 -                             )
[INFO] [stdout] 22412 -                             .into();
[INFO] [stdout] 22411 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22409 ~                         let output: usize = <usize as Into<_>>::into(::glam::UVec3::max_position(
[INFO] [stdout] 22410 |                                 _self.into_inner(),
[INFO] [stdout] 22411 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:22444:43
[INFO] [stdout]       |
[INFO] [stdout] 22444 |                           let output: u32 = ::glam::UVec3::min_element(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 22445 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22444 -                         let output: u32 = ::glam::UVec3::min_element(_self.into_inner())
[INFO] [stdout] 22445 -                             .into();
[INFO] [stdout] 22444 +                         let output: u32 = ::glam::UVec3::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22444 -                         let output: u32 = ::glam::UVec3::min_element(_self.into_inner())
[INFO] [stdout] 22445 -                             .into();
[INFO] [stdout] 22444 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec3::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:22459:45
[INFO] [stdout]       |
[INFO] [stdout] 22459 |                           let output: usize = ::glam::UVec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 22460 | |                                 _self.into_inner(),
[INFO] [stdout] 22461 | |                             )
[INFO] [stdout] 22462 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22461 -                             )
[INFO] [stdout] 22462 -                             .into();
[INFO] [stdout] 22461 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22459 ~                         let output: usize = <usize as Into<_>>::into(::glam::UVec3::min_position(
[INFO] [stdout] 22460 |                                 _self.into_inner(),
[INFO] [stdout] 22461 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u32; 3]`
[INFO] [stdout]      --> src/lib.rs:22771:48
[INFO] [stdout]       |
[INFO] [stdout] 22771 |                         let output: [u32; 3] = ::glam::UVec3::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 22771 -                         let output: [u32; 3] = ::glam::UVec3::to_array(&_self).into();
[INFO] [stdout] 22771 +                         let output: [u32; 3] = ::glam::UVec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 22771 -                         let output: [u32; 3] = ::glam::UVec3::to_array(&_self).into();
[INFO] [stdout] 22771 +                         let output: [u32; 3] = <[u32; 3] as Into<_>>::into(::glam::UVec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:23158:43
[INFO] [stdout]       |
[INFO] [stdout] 23158 |                           let output: u32 = ::glam::UVec4::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 23159 | |                                 _self.into_inner(),
[INFO] [stdout] 23160 | |                                 rhs.into_inner(),
[INFO] [stdout] 23161 | |                             )
[INFO] [stdout] 23162 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23161 -                             )
[INFO] [stdout] 23162 -                             .into();
[INFO] [stdout] 23161 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23158 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec4::chebyshev_distance(
[INFO] [stdout] 23159 |                                 _self.into_inner(),
[INFO] [stdout] 23160 |                                 rhs.into_inner(),
[INFO] [stdout] 23161 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]      --> src/lib.rs:23176:67
[INFO] [stdout]       |
[INFO] [stdout] 23176 |                           let output: ::core::option::Option<u32> = ::glam::UVec4::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 23177 | |                                 _self.into_inner(),
[INFO] [stdout] 23178 | |                                 rhs.into_inner(),
[INFO] [stdout] 23179 | |                             )
[INFO] [stdout] 23180 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23179 -                             )
[INFO] [stdout] 23180 -                             .into();
[INFO] [stdout] 23179 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23176 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::UVec4::checked_manhattan_distance(
[INFO] [stdout] 23177 |                                 _self.into_inner(),
[INFO] [stdout] 23178 |                                 rhs.into_inner(),
[INFO] [stdout] 23179 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:23389:43
[INFO] [stdout]       |
[INFO] [stdout] 23389 |                           let output: u32 = ::glam::UVec4::dot(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 23390 | |                                 _self.into_inner(),
[INFO] [stdout] 23391 | |                                 rhs.into_inner(),
[INFO] [stdout] 23392 | |                             )
[INFO] [stdout] 23393 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23392 -                             )
[INFO] [stdout] 23393 -                             .into();
[INFO] [stdout] 23392 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23389 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec4::dot(
[INFO] [stdout] 23390 |                                 _self.into_inner(),
[INFO] [stdout] 23391 |                                 rhs.into_inner(),
[INFO] [stdout] 23392 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:23425:43
[INFO] [stdout]       |
[INFO] [stdout] 23425 |                           let output: u32 = ::glam::UVec4::element_product(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 23426 | |                                 _self.into_inner(),
[INFO] [stdout] 23427 | |                             )
[INFO] [stdout] 23428 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23427 -                             )
[INFO] [stdout] 23428 -                             .into();
[INFO] [stdout] 23427 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23425 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec4::element_product(
[INFO] [stdout] 23426 |                                 _self.into_inner(),
[INFO] [stdout] 23427 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:23442:43
[INFO] [stdout]       |
[INFO] [stdout] 23442 |                           let output: u32 = ::glam::UVec4::element_sum(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 23443 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23442 -                         let output: u32 = ::glam::UVec4::element_sum(_self.into_inner())
[INFO] [stdout] 23443 -                             .into();
[INFO] [stdout] 23442 +                         let output: u32 = ::glam::UVec4::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23442 -                         let output: u32 = ::glam::UVec4::element_sum(_self.into_inner())
[INFO] [stdout] 23443 -                             .into();
[INFO] [stdout] 23442 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec4::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:23457:44
[INFO] [stdout]       |
[INFO] [stdout] 23457 |                           let output: bool = <::glam::UVec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 23458 | |                             ::glam::UVec4,
[INFO] [stdout] 23459 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 23460 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23459 -                         >>::eq(&_self, &other)
[INFO] [stdout] 23460 -                             .into();
[INFO] [stdout] 23459 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23457 ~                         let output: bool = <bool as Into<_>>::into(<::glam::UVec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 23458 |                             ::glam::UVec4,
[INFO] [stdout] 23459 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:23489:43
[INFO] [stdout]       |
[INFO] [stdout] 23489 |                           let output: u32 = ::glam::UVec4::length_squared(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 23490 | |                                 _self.into_inner(),
[INFO] [stdout] 23491 | |                             )
[INFO] [stdout] 23492 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23491 -                             )
[INFO] [stdout] 23492 -                             .into();
[INFO] [stdout] 23491 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23489 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec4::length_squared(
[INFO] [stdout] 23490 |                                 _self.into_inner(),
[INFO] [stdout] 23491 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:23506:43
[INFO] [stdout]       |
[INFO] [stdout] 23506 |                           let output: u32 = ::glam::UVec4::manhattan_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 23507 | |                                 _self.into_inner(),
[INFO] [stdout] 23508 | |                                 rhs.into_inner(),
[INFO] [stdout] 23509 | |                             )
[INFO] [stdout] 23510 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23509 -                             )
[INFO] [stdout] 23510 -                             .into();
[INFO] [stdout] 23509 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23506 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec4::manhattan_distance(
[INFO] [stdout] 23507 |                                 _self.into_inner(),
[INFO] [stdout] 23508 |                                 rhs.into_inner(),
[INFO] [stdout] 23509 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:23542:43
[INFO] [stdout]       |
[INFO] [stdout] 23542 |                           let output: u32 = ::glam::UVec4::max_element(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 23543 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23542 -                         let output: u32 = ::glam::UVec4::max_element(_self.into_inner())
[INFO] [stdout] 23543 -                             .into();
[INFO] [stdout] 23542 +                         let output: u32 = ::glam::UVec4::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23542 -                         let output: u32 = ::glam::UVec4::max_element(_self.into_inner())
[INFO] [stdout] 23543 -                             .into();
[INFO] [stdout] 23542 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec4::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:23557:45
[INFO] [stdout]       |
[INFO] [stdout] 23557 |                           let output: usize = ::glam::UVec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 23558 | |                                 _self.into_inner(),
[INFO] [stdout] 23559 | |                             )
[INFO] [stdout] 23560 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23559 -                             )
[INFO] [stdout] 23560 -                             .into();
[INFO] [stdout] 23559 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23557 ~                         let output: usize = <usize as Into<_>>::into(::glam::UVec4::max_position(
[INFO] [stdout] 23558 |                                 _self.into_inner(),
[INFO] [stdout] 23559 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]      --> src/lib.rs:23592:43
[INFO] [stdout]       |
[INFO] [stdout] 23592 |                           let output: u32 = ::glam::UVec4::min_element(_self.into_inner())
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 23593 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23592 -                         let output: u32 = ::glam::UVec4::min_element(_self.into_inner())
[INFO] [stdout] 23593 -                             .into();
[INFO] [stdout] 23592 +                         let output: u32 = ::glam::UVec4::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23592 -                         let output: u32 = ::glam::UVec4::min_element(_self.into_inner())
[INFO] [stdout] 23593 -                             .into();
[INFO] [stdout] 23592 +                         let output: u32 = <u32 as Into<_>>::into(::glam::UVec4::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:23607:45
[INFO] [stdout]       |
[INFO] [stdout] 23607 |                           let output: usize = ::glam::UVec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 23608 | |                                 _self.into_inner(),
[INFO] [stdout] 23609 | |                             )
[INFO] [stdout] 23610 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23609 -                             )
[INFO] [stdout] 23610 -                             .into();
[INFO] [stdout] 23609 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23607 ~                         let output: usize = <usize as Into<_>>::into(::glam::UVec4::min_position(
[INFO] [stdout] 23608 |                                 _self.into_inner(),
[INFO] [stdout] 23609 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u32; 4]`
[INFO] [stdout]      --> src/lib.rs:23919:48
[INFO] [stdout]       |
[INFO] [stdout] 23919 |                         let output: [u32; 4] = ::glam::UVec4::to_array(&_self).into();
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 23919 -                         let output: [u32; 4] = ::glam::UVec4::to_array(&_self).into();
[INFO] [stdout] 23919 +                         let output: [u32; 4] = ::glam::UVec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 23919 -                         let output: [u32; 4] = ::glam::UVec4::to_array(&_self).into();
[INFO] [stdout] 23919 +                         let output: [u32; 4] = <[u32; 4] as Into<_>>::into(::glam::UVec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:24324:42
[INFO] [stdout]       |
[INFO] [stdout] 24324 |                           let output: u8 = ::glam::U8Vec2::chebyshev_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 24325 | |                                 _self.into_inner(),
[INFO] [stdout] 24326 | |                                 rhs.into_inner(),
[INFO] [stdout] 24327 | |                             )
[INFO] [stdout] 24328 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24327 -                             )
[INFO] [stdout] 24328 -                             .into();
[INFO] [stdout] 24327 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24324 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec2::chebyshev_distance(
[INFO] [stdout] 24325 |                                 _self.into_inner(),
[INFO] [stdout] 24326 |                                 rhs.into_inner(),
[INFO] [stdout] 24327 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]      --> src/lib.rs:24342:66
[INFO] [stdout]       |
[INFO] [stdout] 24342 |                           let output: ::core::option::Option<u8> = ::glam::U8Vec2::checked_manhattan_distance(
[INFO] [stdout]       |  __________________________________________________________________^
[INFO] [stdout] 24343 | |                                 _self.into_inner(),
[INFO] [stdout] 24344 | |                                 rhs.into_inner(),
[INFO] [stdout] 24345 | |                             )
[INFO] [stdout] 24346 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24345 -                             )
[INFO] [stdout] 24346 -                             .into();
[INFO] [stdout] 24345 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24342 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::U8Vec2::checked_manhattan_distance(
[INFO] [stdout] 24343 |                                 _self.into_inner(),
[INFO] [stdout] 24344 |                                 rhs.into_inner(),
[INFO] [stdout] 24345 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:24555:42
[INFO] [stdout]       |
[INFO] [stdout] 24555 |                           let output: u8 = ::glam::U8Vec2::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 24556 | |                                 _self.into_inner(),
[INFO] [stdout] 24557 | |                                 rhs.into_inner(),
[INFO] [stdout] 24558 | |                             )
[INFO] [stdout] 24559 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24558 -                             )
[INFO] [stdout] 24559 -                             .into();
[INFO] [stdout] 24558 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24555 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec2::dot(
[INFO] [stdout] 24556 |                                 _self.into_inner(),
[INFO] [stdout] 24557 |                                 rhs.into_inner(),
[INFO] [stdout] 24558 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:24591:42
[INFO] [stdout]       |
[INFO] [stdout] 24591 |                           let output: u8 = ::glam::U8Vec2::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 24592 | |                                 _self.into_inner(),
[INFO] [stdout] 24593 | |                             )
[INFO] [stdout] 24594 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24593 -                             )
[INFO] [stdout] 24594 -                             .into();
[INFO] [stdout] 24593 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24591 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec2::element_product(
[INFO] [stdout] 24592 |                                 _self.into_inner(),
[INFO] [stdout] 24593 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:24608:42
[INFO] [stdout]       |
[INFO] [stdout] 24608 |                           let output: u8 = ::glam::U8Vec2::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 24609 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24608 -                         let output: u8 = ::glam::U8Vec2::element_sum(_self.into_inner())
[INFO] [stdout] 24609 -                             .into();
[INFO] [stdout] 24608 +                         let output: u8 = ::glam::U8Vec2::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24608 -                         let output: u8 = ::glam::U8Vec2::element_sum(_self.into_inner())
[INFO] [stdout] 24609 -                             .into();
[INFO] [stdout] 24608 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec2::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:24623:44
[INFO] [stdout]       |
[INFO] [stdout] 24623 |                           let output: bool = <::glam::U8Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 24624 | |                             ::glam::U8Vec2,
[INFO] [stdout] 24625 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 24626 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24625 -                         >>::eq(&_self, &other)
[INFO] [stdout] 24626 -                             .into();
[INFO] [stdout] 24625 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24623 ~                         let output: bool = <bool as Into<_>>::into(<::glam::U8Vec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 24624 |                             ::glam::U8Vec2,
[INFO] [stdout] 24625 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:24673:42
[INFO] [stdout]       |
[INFO] [stdout] 24673 |                           let output: u8 = ::glam::U8Vec2::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 24674 | |                                 _self.into_inner(),
[INFO] [stdout] 24675 | |                             )
[INFO] [stdout] 24676 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24675 -                             )
[INFO] [stdout] 24676 -                             .into();
[INFO] [stdout] 24675 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24673 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec2::length_squared(
[INFO] [stdout] 24674 |                                 _self.into_inner(),
[INFO] [stdout] 24675 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:24690:42
[INFO] [stdout]       |
[INFO] [stdout] 24690 |                           let output: u8 = ::glam::U8Vec2::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 24691 | |                                 _self.into_inner(),
[INFO] [stdout] 24692 | |                                 rhs.into_inner(),
[INFO] [stdout] 24693 | |                             )
[INFO] [stdout] 24694 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24693 -                             )
[INFO] [stdout] 24694 -                             .into();
[INFO] [stdout] 24693 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24690 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec2::manhattan_distance(
[INFO] [stdout] 24691 |                                 _self.into_inner(),
[INFO] [stdout] 24692 |                                 rhs.into_inner(),
[INFO] [stdout] 24693 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:24726:42
[INFO] [stdout]       |
[INFO] [stdout] 24726 |                           let output: u8 = ::glam::U8Vec2::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 24727 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24726 -                         let output: u8 = ::glam::U8Vec2::max_element(_self.into_inner())
[INFO] [stdout] 24727 -                             .into();
[INFO] [stdout] 24726 +                         let output: u8 = ::glam::U8Vec2::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24726 -                         let output: u8 = ::glam::U8Vec2::max_element(_self.into_inner())
[INFO] [stdout] 24727 -                             .into();
[INFO] [stdout] 24726 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec2::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:24741:45
[INFO] [stdout]       |
[INFO] [stdout] 24741 |                           let output: usize = ::glam::U8Vec2::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 24742 | |                                 _self.into_inner(),
[INFO] [stdout] 24743 | |                             )
[INFO] [stdout] 24744 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24743 -                             )
[INFO] [stdout] 24744 -                             .into();
[INFO] [stdout] 24743 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24741 ~                         let output: usize = <usize as Into<_>>::into(::glam::U8Vec2::max_position(
[INFO] [stdout] 24742 |                                 _self.into_inner(),
[INFO] [stdout] 24743 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:24776:42
[INFO] [stdout]       |
[INFO] [stdout] 24776 |                           let output: u8 = ::glam::U8Vec2::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 24777 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24776 -                         let output: u8 = ::glam::U8Vec2::min_element(_self.into_inner())
[INFO] [stdout] 24777 -                             .into();
[INFO] [stdout] 24776 +                         let output: u8 = ::glam::U8Vec2::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24776 -                         let output: u8 = ::glam::U8Vec2::min_element(_self.into_inner())
[INFO] [stdout] 24777 -                             .into();
[INFO] [stdout] 24776 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec2::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:24791:45
[INFO] [stdout]       |
[INFO] [stdout] 24791 |                           let output: usize = ::glam::U8Vec2::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 24792 | |                                 _self.into_inner(),
[INFO] [stdout] 24793 | |                             )
[INFO] [stdout] 24794 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 24793 -                             )
[INFO] [stdout] 24794 -                             .into();
[INFO] [stdout] 24793 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 24791 ~                         let output: usize = <usize as Into<_>>::into(::glam::U8Vec2::min_position(
[INFO] [stdout] 24792 |                                 _self.into_inner(),
[INFO] [stdout] 24793 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 2]`
[INFO] [stdout]      --> src/lib.rs:25102:47
[INFO] [stdout]       |
[INFO] [stdout] 25102 |                         let output: [u8; 2] = ::glam::U8Vec2::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25102 -                         let output: [u8; 2] = ::glam::U8Vec2::to_array(&_self).into();
[INFO] [stdout] 25102 +                         let output: [u8; 2] = ::glam::U8Vec2::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25102 -                         let output: [u8; 2] = ::glam::U8Vec2::to_array(&_self).into();
[INFO] [stdout] 25102 +                         let output: [u8; 2] = <[u8; 2] as Into<_>>::into(::glam::U8Vec2::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:25471:42
[INFO] [stdout]       |
[INFO] [stdout] 25471 |                           let output: u8 = ::glam::U8Vec3::chebyshev_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 25472 | |                                 _self.into_inner(),
[INFO] [stdout] 25473 | |                                 rhs.into_inner(),
[INFO] [stdout] 25474 | |                             )
[INFO] [stdout] 25475 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25474 -                             )
[INFO] [stdout] 25475 -                             .into();
[INFO] [stdout] 25474 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25471 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec3::chebyshev_distance(
[INFO] [stdout] 25472 |                                 _self.into_inner(),
[INFO] [stdout] 25473 |                                 rhs.into_inner(),
[INFO] [stdout] 25474 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]      --> src/lib.rs:25489:66
[INFO] [stdout]       |
[INFO] [stdout] 25489 |                           let output: ::core::option::Option<u8> = ::glam::U8Vec3::checked_manhattan_distance(
[INFO] [stdout]       |  __________________________________________________________________^
[INFO] [stdout] 25490 | |                                 _self.into_inner(),
[INFO] [stdout] 25491 | |                                 rhs.into_inner(),
[INFO] [stdout] 25492 | |                             )
[INFO] [stdout] 25493 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25492 -                             )
[INFO] [stdout] 25493 -                             .into();
[INFO] [stdout] 25492 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25489 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::U8Vec3::checked_manhattan_distance(
[INFO] [stdout] 25490 |                                 _self.into_inner(),
[INFO] [stdout] 25491 |                                 rhs.into_inner(),
[INFO] [stdout] 25492 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:25720:42
[INFO] [stdout]       |
[INFO] [stdout] 25720 |                           let output: u8 = ::glam::U8Vec3::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 25721 | |                                 _self.into_inner(),
[INFO] [stdout] 25722 | |                                 rhs.into_inner(),
[INFO] [stdout] 25723 | |                             )
[INFO] [stdout] 25724 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25723 -                             )
[INFO] [stdout] 25724 -                             .into();
[INFO] [stdout] 25723 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25720 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec3::dot(
[INFO] [stdout] 25721 |                                 _self.into_inner(),
[INFO] [stdout] 25722 |                                 rhs.into_inner(),
[INFO] [stdout] 25723 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:25756:42
[INFO] [stdout]       |
[INFO] [stdout] 25756 |                           let output: u8 = ::glam::U8Vec3::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 25757 | |                                 _self.into_inner(),
[INFO] [stdout] 25758 | |                             )
[INFO] [stdout] 25759 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25758 -                             )
[INFO] [stdout] 25759 -                             .into();
[INFO] [stdout] 25758 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25756 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec3::element_product(
[INFO] [stdout] 25757 |                                 _self.into_inner(),
[INFO] [stdout] 25758 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:25773:42
[INFO] [stdout]       |
[INFO] [stdout] 25773 |                           let output: u8 = ::glam::U8Vec3::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 25774 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25773 -                         let output: u8 = ::glam::U8Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 25774 -                             .into();
[INFO] [stdout] 25773 +                         let output: u8 = ::glam::U8Vec3::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25773 -                         let output: u8 = ::glam::U8Vec3::element_sum(_self.into_inner())
[INFO] [stdout] 25774 -                             .into();
[INFO] [stdout] 25773 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec3::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:25788:44
[INFO] [stdout]       |
[INFO] [stdout] 25788 |                           let output: bool = <::glam::U8Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 25789 | |                             ::glam::U8Vec3,
[INFO] [stdout] 25790 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 25791 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25790 -                         >>::eq(&_self, &other)
[INFO] [stdout] 25791 -                             .into();
[INFO] [stdout] 25790 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25788 ~                         let output: bool = <bool as Into<_>>::into(<::glam::U8Vec3 as ::core::cmp::PartialEq<
[INFO] [stdout] 25789 |                             ::glam::U8Vec3,
[INFO] [stdout] 25790 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:25838:42
[INFO] [stdout]       |
[INFO] [stdout] 25838 |                           let output: u8 = ::glam::U8Vec3::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 25839 | |                                 _self.into_inner(),
[INFO] [stdout] 25840 | |                             )
[INFO] [stdout] 25841 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25840 -                             )
[INFO] [stdout] 25841 -                             .into();
[INFO] [stdout] 25840 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25838 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec3::length_squared(
[INFO] [stdout] 25839 |                                 _self.into_inner(),
[INFO] [stdout] 25840 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:25855:42
[INFO] [stdout]       |
[INFO] [stdout] 25855 |                           let output: u8 = ::glam::U8Vec3::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 25856 | |                                 _self.into_inner(),
[INFO] [stdout] 25857 | |                                 rhs.into_inner(),
[INFO] [stdout] 25858 | |                             )
[INFO] [stdout] 25859 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25858 -                             )
[INFO] [stdout] 25859 -                             .into();
[INFO] [stdout] 25858 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25855 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec3::manhattan_distance(
[INFO] [stdout] 25856 |                                 _self.into_inner(),
[INFO] [stdout] 25857 |                                 rhs.into_inner(),
[INFO] [stdout] 25858 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:25891:42
[INFO] [stdout]       |
[INFO] [stdout] 25891 |                           let output: u8 = ::glam::U8Vec3::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 25892 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25891 -                         let output: u8 = ::glam::U8Vec3::max_element(_self.into_inner())
[INFO] [stdout] 25892 -                             .into();
[INFO] [stdout] 25891 +                         let output: u8 = ::glam::U8Vec3::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25891 -                         let output: u8 = ::glam::U8Vec3::max_element(_self.into_inner())
[INFO] [stdout] 25892 -                             .into();
[INFO] [stdout] 25891 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec3::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:25906:45
[INFO] [stdout]       |
[INFO] [stdout] 25906 |                           let output: usize = ::glam::U8Vec3::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 25907 | |                                 _self.into_inner(),
[INFO] [stdout] 25908 | |                             )
[INFO] [stdout] 25909 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25908 -                             )
[INFO] [stdout] 25909 -                             .into();
[INFO] [stdout] 25908 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25906 ~                         let output: usize = <usize as Into<_>>::into(::glam::U8Vec3::max_position(
[INFO] [stdout] 25907 |                                 _self.into_inner(),
[INFO] [stdout] 25908 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:25941:42
[INFO] [stdout]       |
[INFO] [stdout] 25941 |                           let output: u8 = ::glam::U8Vec3::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 25942 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25941 -                         let output: u8 = ::glam::U8Vec3::min_element(_self.into_inner())
[INFO] [stdout] 25942 -                             .into();
[INFO] [stdout] 25941 +                         let output: u8 = ::glam::U8Vec3::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25941 -                         let output: u8 = ::glam::U8Vec3::min_element(_self.into_inner())
[INFO] [stdout] 25942 -                             .into();
[INFO] [stdout] 25941 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec3::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:25956:45
[INFO] [stdout]       |
[INFO] [stdout] 25956 |                           let output: usize = ::glam::U8Vec3::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 25957 | |                                 _self.into_inner(),
[INFO] [stdout] 25958 | |                             )
[INFO] [stdout] 25959 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 25958 -                             )
[INFO] [stdout] 25959 -                             .into();
[INFO] [stdout] 25958 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 25956 ~                         let output: usize = <usize as Into<_>>::into(::glam::U8Vec3::min_position(
[INFO] [stdout] 25957 |                                 _self.into_inner(),
[INFO] [stdout] 25958 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 3]`
[INFO] [stdout]      --> src/lib.rs:26268:47
[INFO] [stdout]       |
[INFO] [stdout] 26268 |                         let output: [u8; 3] = ::glam::U8Vec3::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 26268 -                         let output: [u8; 3] = ::glam::U8Vec3::to_array(&_self).into();
[INFO] [stdout] 26268 +                         let output: [u8; 3] = ::glam::U8Vec3::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 26268 -                         let output: [u8; 3] = ::glam::U8Vec3::to_array(&_self).into();
[INFO] [stdout] 26268 +                         let output: [u8; 3] = <[u8; 3] as Into<_>>::into(::glam::U8Vec3::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:26655:42
[INFO] [stdout]       |
[INFO] [stdout] 26655 |                           let output: u8 = ::glam::U8Vec4::chebyshev_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 26656 | |                                 _self.into_inner(),
[INFO] [stdout] 26657 | |                                 rhs.into_inner(),
[INFO] [stdout] 26658 | |                             )
[INFO] [stdout] 26659 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 26658 -                             )
[INFO] [stdout] 26659 -                             .into();
[INFO] [stdout] 26658 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 26655 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec4::chebyshev_distance(
[INFO] [stdout] 26656 |                                 _self.into_inner(),
[INFO] [stdout] 26657 |                                 rhs.into_inner(),
[INFO] [stdout] 26658 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u32>`
[INFO] [stdout]     --> src/lib.rs:4494:67
[INFO] [stdout]      |
[INFO] [stdout] 4494 |                           let output: ::core::option::Option<u32> = ::glam::IVec2::checked_manhattan_distance(
[INFO] [stdout]      |  ___________________________________________________________________^
[INFO] [stdout] 4495 | |                                 _self.into_inner(),
[INFO] [stdout] 4496 | |                                 rhs.into_inner(),
[INFO] [stdout] 4497 | |                             )
[INFO] [stdout] 4498 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4497 -                             )
[INFO] [stdout] 4498 -                             .into();
[INFO] [stdout] 4497 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4494 ~                         let output: ::core::option::Option<u32> = <std::option::Option<u32> as Into<_>>::into(::glam::IVec2::checked_manhattan_distance(
[INFO] [stdout] 4495 |                                 _self.into_inner(),
[INFO] [stdout] 4496 |                                 rhs.into_inner(),
[INFO] [stdout] 4497 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4656:43
[INFO] [stdout]      |
[INFO] [stdout] 4656 |                           let output: i32 = ::glam::IVec2::distance_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4657 | |                                 _self.into_inner(),
[INFO] [stdout] 4658 | |                                 rhs.into_inner(),
[INFO] [stdout] 4659 | |                             )
[INFO] [stdout] 4660 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4659 -                             )
[INFO] [stdout] 4660 -                             .into();
[INFO] [stdout] 4659 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4656 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::distance_squared(
[INFO] [stdout] 4657 |                                 _self.into_inner(),
[INFO] [stdout] 4658 |                                 rhs.into_inner(),
[INFO] [stdout] 4659 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u8>`
[INFO] [stdout]      --> src/lib.rs:26673:66
[INFO] [stdout]       |
[INFO] [stdout] 26673 |                           let output: ::core::option::Option<u8> = ::glam::U8Vec4::checked_manhattan_distance(
[INFO] [stdout]       |  __________________________________________________________________^
[INFO] [stdout] 26674 | |                                 _self.into_inner(),
[INFO] [stdout] 26675 | |                                 rhs.into_inner(),
[INFO] [stdout] 26676 | |                             )
[INFO] [stdout] 26677 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 26676 -                             )
[INFO] [stdout] 26677 -                             .into();
[INFO] [stdout] 26676 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 26673 ~                         let output: ::core::option::Option<u8> = <std::option::Option<u8> as Into<_>>::into(::glam::U8Vec4::checked_manhattan_distance(
[INFO] [stdout] 26674 |                                 _self.into_inner(),
[INFO] [stdout] 26675 |                                 rhs.into_inner(),
[INFO] [stdout] 26676 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4743:43
[INFO] [stdout]      |
[INFO] [stdout] 4743 |                           let output: i32 = ::glam::IVec2::dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4744 | |                                 _self.into_inner(),
[INFO] [stdout] 4745 | |                                 rhs.into_inner(),
[INFO] [stdout] 4746 | |                             )
[INFO] [stdout] 4747 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4746 -                             )
[INFO] [stdout] 4747 -                             .into();
[INFO] [stdout] 4746 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4743 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::dot(
[INFO] [stdout] 4744 |                                 _self.into_inner(),
[INFO] [stdout] 4745 |                                 rhs.into_inner(),
[INFO] [stdout] 4746 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4779:43
[INFO] [stdout]      |
[INFO] [stdout] 4779 |                           let output: i32 = ::glam::IVec2::element_product(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4780 | |                                 _self.into_inner(),
[INFO] [stdout] 4781 | |                             )
[INFO] [stdout] 4782 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4781 -                             )
[INFO] [stdout] 4782 -                             .into();
[INFO] [stdout] 4781 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4779 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::element_product(
[INFO] [stdout] 4780 |                                 _self.into_inner(),
[INFO] [stdout] 4781 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:26886:42
[INFO] [stdout]       |
[INFO] [stdout] 26886 |                           let output: u8 = ::glam::U8Vec4::dot(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 26887 | |                                 _self.into_inner(),
[INFO] [stdout] 26888 | |                                 rhs.into_inner(),
[INFO] [stdout] 26889 | |                             )
[INFO] [stdout] 26890 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 26889 -                             )
[INFO] [stdout] 26890 -                             .into();
[INFO] [stdout] 26889 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 26886 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec4::dot(
[INFO] [stdout] 26887 |                                 _self.into_inner(),
[INFO] [stdout] 26888 |                                 rhs.into_inner(),
[INFO] [stdout] 26889 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4796:43
[INFO] [stdout]      |
[INFO] [stdout] 4796 |                           let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4797 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4796 -                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout] 4797 -                             .into();
[INFO] [stdout] 4796 +                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4796 -                         let output: i32 = ::glam::IVec2::element_sum(_self.into_inner())
[INFO] [stdout] 4797 -                             .into();
[INFO] [stdout] 4796 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::element_sum(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:26922:42
[INFO] [stdout]       |
[INFO] [stdout] 26922 |                           let output: u8 = ::glam::U8Vec4::element_product(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 26923 | |                                 _self.into_inner(),
[INFO] [stdout] 26924 | |                             )
[INFO] [stdout] 26925 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 26924 -                             )
[INFO] [stdout] 26925 -                             .into();
[INFO] [stdout] 26924 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 26922 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec4::element_product(
[INFO] [stdout] 26923 |                                 _self.into_inner(),
[INFO] [stdout] 26924 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]     --> src/lib.rs:4811:44
[INFO] [stdout]      |
[INFO] [stdout] 4811 |                           let output: bool = <::glam::IVec2 as ::core::cmp::PartialEq<
[INFO] [stdout]      |  ____________________________________________^
[INFO] [stdout] 4812 | |                             ::glam::IVec2,
[INFO] [stdout] 4813 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 4814 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4813 -                         >>::eq(&_self, &other)
[INFO] [stdout] 4814 -                             .into();
[INFO] [stdout] 4813 +                         >>::eq(&_self, &other);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4811 ~                         let output: bool = <bool as Into<_>>::into(<::glam::IVec2 as ::core::cmp::PartialEq<
[INFO] [stdout] 4812 |                             ::glam::IVec2,
[INFO] [stdout] 4813 ~                         >>::eq(&_self, &other));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:26939:42
[INFO] [stdout]       |
[INFO] [stdout] 26939 |                           let output: u8 = ::glam::U8Vec4::element_sum(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 26940 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 26939 -                         let output: u8 = ::glam::U8Vec4::element_sum(_self.into_inner())
[INFO] [stdout] 26940 -                             .into();
[INFO] [stdout] 26939 +                         let output: u8 = ::glam::U8Vec4::element_sum(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 26939 -                         let output: u8 = ::glam::U8Vec4::element_sum(_self.into_inner())
[INFO] [stdout] 26940 -                             .into();
[INFO] [stdout] 26939 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec4::element_sum(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4861:43
[INFO] [stdout]      |
[INFO] [stdout] 4861 |                           let output: u32 = ::glam::IVec2::is_negative_bitmask(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4862 | |                                 _self.into_inner(),
[INFO] [stdout] 4863 | |                             )
[INFO] [stdout] 4864 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4863 -                             )
[INFO] [stdout] 4864 -                             .into();
[INFO] [stdout] 4863 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4861 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::is_negative_bitmask(
[INFO] [stdout] 4862 |                                 _self.into_inner(),
[INFO] [stdout] 4863 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]      --> src/lib.rs:26954:44
[INFO] [stdout]       |
[INFO] [stdout] 26954 |                           let output: bool = <::glam::U8Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout]       |  ____________________________________________^
[INFO] [stdout] 26955 | |                             ::glam::U8Vec4,
[INFO] [stdout] 26956 | |                         >>::eq(&_self, &other)
[INFO] [stdout] 26957 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 26956 -                         >>::eq(&_self, &other)
[INFO] [stdout] 26957 -                             .into();
[INFO] [stdout] 26956 +                         >>::eq(&_self, &other);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 26954 ~                         let output: bool = <bool as Into<_>>::into(<::glam::U8Vec4 as ::core::cmp::PartialEq<
[INFO] [stdout] 26955 |                             ::glam::U8Vec4,
[INFO] [stdout] 26956 ~                         >>::eq(&_self, &other));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:26986:42
[INFO] [stdout]       |
[INFO] [stdout] 26986 |                           let output: u8 = ::glam::U8Vec4::length_squared(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 26987 | |                                 _self.into_inner(),
[INFO] [stdout] 26988 | |                             )
[INFO] [stdout] 26989 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 26988 -                             )
[INFO] [stdout] 26989 -                             .into();
[INFO] [stdout] 26988 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 26986 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec4::length_squared(
[INFO] [stdout] 26987 |                                 _self.into_inner(),
[INFO] [stdout] 26988 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4895:43
[INFO] [stdout]      |
[INFO] [stdout] 4895 |                           let output: i32 = ::glam::IVec2::length_squared(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4896 | |                                 _self.into_inner(),
[INFO] [stdout] 4897 | |                             )
[INFO] [stdout] 4898 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4897 -                             )
[INFO] [stdout] 4898 -                             .into();
[INFO] [stdout] 4897 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4895 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::length_squared(
[INFO] [stdout] 4896 |                                 _self.into_inner(),
[INFO] [stdout] 4897 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:27003:42
[INFO] [stdout]       |
[INFO] [stdout] 27003 |                           let output: u8 = ::glam::U8Vec4::manhattan_distance(
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 27004 | |                                 _self.into_inner(),
[INFO] [stdout] 27005 | |                                 rhs.into_inner(),
[INFO] [stdout] 27006 | |                             )
[INFO] [stdout] 27007 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 27006 -                             )
[INFO] [stdout] 27007 -                             .into();
[INFO] [stdout] 27006 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 27003 ~                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec4::manhattan_distance(
[INFO] [stdout] 27004 |                                 _self.into_inner(),
[INFO] [stdout] 27005 |                                 rhs.into_inner(),
[INFO] [stdout] 27006 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:4912:43
[INFO] [stdout]      |
[INFO] [stdout] 4912 |                           let output: u32 = ::glam::IVec2::manhattan_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4913 | |                                 _self.into_inner(),
[INFO] [stdout] 4914 | |                                 rhs.into_inner(),
[INFO] [stdout] 4915 | |                             )
[INFO] [stdout] 4916 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4915 -                             )
[INFO] [stdout] 4916 -                             .into();
[INFO] [stdout] 4915 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4912 ~                         let output: u32 = <u32 as Into<_>>::into(::glam::IVec2::manhattan_distance(
[INFO] [stdout] 4913 |                                 _self.into_inner(),
[INFO] [stdout] 4914 |                                 rhs.into_inner(),
[INFO] [stdout] 4915 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:27039:42
[INFO] [stdout]       |
[INFO] [stdout] 27039 |                           let output: u8 = ::glam::U8Vec4::max_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 27040 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 27039 -                         let output: u8 = ::glam::U8Vec4::max_element(_self.into_inner())
[INFO] [stdout] 27040 -                             .into();
[INFO] [stdout] 27039 +                         let output: u8 = ::glam::U8Vec4::max_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 27039 -                         let output: u8 = ::glam::U8Vec4::max_element(_self.into_inner())
[INFO] [stdout] 27040 -                             .into();
[INFO] [stdout] 27039 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec4::max_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4948:43
[INFO] [stdout]      |
[INFO] [stdout] 4948 |                           let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4949 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4948 -                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout] 4949 -                             .into();
[INFO] [stdout] 4948 +                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4948 -                         let output: i32 = ::glam::IVec2::max_element(_self.into_inner())
[INFO] [stdout] 4949 -                             .into();
[INFO] [stdout] 4948 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::max_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:27054:45
[INFO] [stdout]       |
[INFO] [stdout] 27054 |                           let output: usize = ::glam::U8Vec4::max_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 27055 | |                                 _self.into_inner(),
[INFO] [stdout] 27056 | |                             )
[INFO] [stdout] 27057 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 27056 -                             )
[INFO] [stdout] 27057 -                             .into();
[INFO] [stdout] 27056 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 27054 ~                         let output: usize = <usize as Into<_>>::into(::glam::U8Vec4::max_position(
[INFO] [stdout] 27055 |                                 _self.into_inner(),
[INFO] [stdout] 27056 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:4963:45
[INFO] [stdout]      |
[INFO] [stdout] 4963 |                           let output: usize = ::glam::IVec2::max_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 4964 | |                                 _self.into_inner(),
[INFO] [stdout] 4965 | |                             )
[INFO] [stdout] 4966 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4965 -                             )
[INFO] [stdout] 4966 -                             .into();
[INFO] [stdout] 4965 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4963 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec2::max_position(
[INFO] [stdout] 4964 |                                 _self.into_inner(),
[INFO] [stdout] 4965 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]      --> src/lib.rs:27089:42
[INFO] [stdout]       |
[INFO] [stdout] 27089 |                           let output: u8 = ::glam::U8Vec4::min_element(_self.into_inner())
[INFO] [stdout]       |  __________________________________________^
[INFO] [stdout] 27090 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 27089 -                         let output: u8 = ::glam::U8Vec4::min_element(_self.into_inner())
[INFO] [stdout] 27090 -                             .into();
[INFO] [stdout] 27089 +                         let output: u8 = ::glam::U8Vec4::min_element(_self.into_inner());
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 27089 -                         let output: u8 = ::glam::U8Vec4::min_element(_self.into_inner())
[INFO] [stdout] 27090 -                             .into();
[INFO] [stdout] 27089 +                         let output: u8 = <u8 as Into<_>>::into(::glam::U8Vec4::min_element(_self.into_inner()));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:4998:43
[INFO] [stdout]      |
[INFO] [stdout] 4998 |                           let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 4999 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4998 -                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout] 4999 -                             .into();
[INFO] [stdout] 4998 +                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner());
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4998 -                         let output: i32 = ::glam::IVec2::min_element(_self.into_inner())
[INFO] [stdout] 4999 -                             .into();
[INFO] [stdout] 4998 +                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::min_element(_self.into_inner()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]      --> src/lib.rs:27104:45
[INFO] [stdout]       |
[INFO] [stdout] 27104 |                           let output: usize = ::glam::U8Vec4::min_position(
[INFO] [stdout]       |  _____________________________________________^
[INFO] [stdout] 27105 | |                                 _self.into_inner(),
[INFO] [stdout] 27106 | |                             )
[INFO] [stdout] 27107 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 27106 -                             )
[INFO] [stdout] 27107 -                             .into();
[INFO] [stdout] 27106 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 27104 ~                         let output: usize = <usize as Into<_>>::into(::glam::U8Vec4::min_position(
[INFO] [stdout] 27105 |                                 _self.into_inner(),
[INFO] [stdout] 27106 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]     --> src/lib.rs:5013:45
[INFO] [stdout]      |
[INFO] [stdout] 5013 |                           let output: usize = ::glam::IVec2::min_position(
[INFO] [stdout]      |  _____________________________________________^
[INFO] [stdout] 5014 | |                                 _self.into_inner(),
[INFO] [stdout] 5015 | |                             )
[INFO] [stdout] 5016 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5015 -                             )
[INFO] [stdout] 5016 -                             .into();
[INFO] [stdout] 5015 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5013 ~                         let output: usize = <usize as Into<_>>::into(::glam::IVec2::min_position(
[INFO] [stdout] 5014 |                                 _self.into_inner(),
[INFO] [stdout] 5015 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 4]`
[INFO] [stdout]      --> src/lib.rs:27416:47
[INFO] [stdout]       |
[INFO] [stdout] 27416 |                         let output: [u8; 4] = ::glam::U8Vec4::to_array(&_self).into();
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 27416 -                         let output: [u8; 4] = ::glam::U8Vec4::to_array(&_self).into();
[INFO] [stdout] 27416 +                         let output: [u8; 4] = ::glam::U8Vec4::to_array(&_self);
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 27416 -                         let output: [u8; 4] = ::glam::U8Vec4::to_array(&_self).into();
[INFO] [stdout] 27416 +                         let output: [u8; 4] = <[u8; 4] as Into<_>>::into(::glam::U8Vec4::to_array(&_self));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i32`
[INFO] [stdout]     --> src/lib.rs:5129:43
[INFO] [stdout]      |
[INFO] [stdout] 5129 |                           let output: i32 = ::glam::IVec2::perp_dot(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 5130 | |                                 _self.into_inner(),
[INFO] [stdout] 5131 | |                                 rhs.into_inner(),
[INFO] [stdout] 5132 | |                             )
[INFO] [stdout] 5133 | |                             .into();
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5132 -                             )
[INFO] [stdout] 5133 -                             .into();
[INFO] [stdout] 5132 +                             );
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5129 ~                         let output: i32 = <i32 as Into<_>>::into(::glam::IVec2::perp_dot(
[INFO] [stdout] 5130 |                                 _self.into_inner(),
[INFO] [stdout] 5131 |                                 rhs.into_inner(),
[INFO] [stdout] 5132 ~                             ));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]      --> src/lib.rs:27821:43
[INFO] [stdout]       |
[INFO] [stdout] 27821 |                           let output: u16 = ::glam::U16Vec2::chebyshev_distance(
[INFO] [stdout]       |  ___________________________________________^
[INFO] [stdout] 27822 | |                                 _self.into_inner(),
[INFO] [stdout] 27823 | |                                 rhs.into_inner(),
[INFO] [stdout] 27824 | |                             )
[INFO] [stdout] 27825 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 27824 -                             )
[INFO] [stdout] 27825 -                             .into();
[INFO] [stdout] 27824 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 27821 ~                         let output: u16 = <u16 as Into<_>>::into(::glam::U16Vec2::chebyshev_distance(
[INFO] [stdout] 27822 |                                 _self.into_inner(),
[INFO] [stdout] 27823 |                                 rhs.into_inner(),
[INFO] [stdout] 27824 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[i32; 2]`
[INFO] [stdout]     --> src/lib.rs:5447:48
[INFO] [stdout]      |
[INFO] [stdout] 5447 |                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5447 -                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout] 5447 +                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5447 -                         let output: [i32; 2] = ::glam::IVec2::to_array(&_self).into();
[INFO] [stdout] 5447 +                         let output: [i32; 2] = <[i32; 2] as Into<_>>::into(::glam::IVec2::to_array(&_self));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `std::option::Option<u16>`
[INFO] [stdout]      --> src/lib.rs:27839:67
[INFO] [stdout]       |
[INFO] [stdout] 27839 |                           let output: ::core::option::Option<u16> = ::glam::U16Vec2::checked_manhattan_distance(
[INFO] [stdout]       |  ___________________________________________________________________^
[INFO] [stdout] 27840 | |                                 _self.into_inner(),
[INFO] [stdout] 27841 | |                                 rhs.into_inner(),
[INFO] [stdout] 27842 | |                             )
[INFO] [stdout] 27843 | |                             .into();
[INFO] [stdout]       | |___________________________________^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 27842 -                             )
[INFO] [stdout] 27843 -                             .into();
[INFO] [stdout] 27842 +                             );
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 27839 ~                         let output: ::core::option::Option<u16> = <std::option::Option<u16> as Into<_>>::into(::glam::U16Vec2::checked_manhattan_distance(
[INFO] [stdout] 27840 |                                 _self.into_inner(),
[INFO] [stdout] 27841 |                                 rhs.into_inner(),
[INFO] [stdout] 27842 ~                             ));
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/lib.rs:5851:43
[INFO] [stdout]      |
[INFO] [stdout] 5851 |                           let output: u32 = ::glam::IVec3::chebyshev_distance(
[INFO] [stdout]      |  ___________________________________________^
[INFO] [stdout] 5852 | |                                 _self.into_inner(),
[INFO] [stdout] 5853 | |                                 rhs.into_inner(),
[INFO] [stdout] 5854 | |                             )
[WARN] too many lines in the log, truncating it
