[INFO] fetching crate massively 0.97.0...
[INFO] checking massively-0.97.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate massively 0.97.0 into /workspace/builds/worker-4-tc2/source
[INFO] started tweaking crates.io crate massively 0.97.0
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate massively 0.97.0
[INFO] tweaked toml for crates.io crate massively 0.97.0 written to /workspace/builds/worker-4-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate massively 0.97.0 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate massively 0.97.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-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] 8b8f5c95dec5697b5982afc24836c3c93ce9c8baf0e0230d25d352e5de66633c
[INFO] running `Command { std: "docker" "start" "8b8f5c95dec5697b5982afc24836c3c93ce9c8baf0e0230d25d352e5de66633c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "8b8f5c95dec5697b5982afc24836c3c93ce9c8baf0e0230d25d352e5de66633c", 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" "8b8f5c95dec5697b5982afc24836c3c93ce9c8baf0e0230d25d352e5de66633c" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "8b8f5c95dec5697b5982afc24836c3c93ce9c8baf0e0230d25d352e5de66633c", 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" "8b8f5c95dec5697b5982afc24836c3c93ce9c8baf0e0230d25d352e5de66633c" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.106
[INFO] [stderr]    Compiling serde_core v1.0.228
[INFO] [stderr]    Compiling cfg_aliases v0.2.2
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling zerocopy v0.8.52
[INFO] [stderr]     Checking memchr v2.8.1
[INFO] [stderr]    Compiling crossbeam-utils v0.8.21
[INFO] [stderr]     Checking log v0.4.32
[INFO] [stderr]    Compiling const_fn v0.4.12
[INFO] [stderr]     Checking unicode-ident v1.0.24
[INFO] [stderr]    Compiling allocator-api2 v0.2.21
[INFO] [stderr]    Compiling quote v1.0.45
[INFO] [stderr]    Compiling awint_internals v0.19.0
[INFO] [stderr]    Compiling cc v1.4.4
[INFO] [stderr]    Compiling hashbrown v0.17.1
[INFO] [stderr]    Compiling convert_case v0.10.0
[INFO] [stderr]    Compiling syn v2.0.117
[INFO] [stderr]    Compiling syn v3.0.4
[INFO] [stderr]    Compiling serde_json v1.0.150
[INFO] [stderr]    Compiling awint_core v0.19.0
[INFO] [stderr]     Checking concurrent-queue v2.5.0
[INFO] [stderr]     Checking aho-corasick v1.1.4
[INFO] [stderr]    Compiling libm v0.2.16
[INFO] [stderr]     Checking either v1.16.0
[INFO] [stderr]     Checking futures-core v0.3.32
[INFO] [stderr]    Compiling recasting v0.2.3
[INFO] [stderr]    Compiling triple_arena v0.15.1
[INFO] [stderr]    Compiling libsqlite3-sys v0.38.2
[INFO] [stderr]     Checking regex-automata v0.4.14
[INFO] [stderr]     Checking bitflags v2.13.1
[INFO] [stderr]     Checking indexmap v2.14.0
[INFO] [stderr]     Checking event-listener v5.4.1
[INFO] [stderr]    Compiling awint_ext v0.19.0
[INFO] [stderr]     Checking num-integer v0.1.46
[INFO] [stderr]     Checking cpufeatures v0.3.0
[INFO] [stderr]    Compiling linkme-impl v0.3.37
[INFO] [stderr]     Checking winnow v1.0.3
[INFO] [stderr]    Compiling awint_macro_internals v0.19.0
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]     Checking regex v1.12.4
[INFO] [stderr]     Checking toml_parser v1.1.2+spec-1.1.0
[INFO] [stderr]    Compiling darling_core v0.21.3
[INFO] [stderr]    Compiling darling_core v0.24.1
[INFO] [stderr]     Checking chacha20 v0.10.2
[INFO] [stderr]     Checking event-listener-strategy v0.5.4
[INFO] [stderr]     Checking object v0.37.3
[INFO] [stderr]     Checking getrandom v0.4.3
[INFO] [stderr]     Checking hashlink v0.12.1
[INFO] [stderr]     Checking serde_spanned v1.1.1
[INFO] [stderr]     Checking toml_datetime v1.1.1+spec-1.1.0
[INFO] [stderr]    Compiling slotmap v1.1.1
[INFO] [stderr]     Checking spin v0.12.3
[INFO] [stderr]    Compiling cubecl-environment v0.11.0-pre.3
[INFO] [stderr]     Checking libloading v0.8.9
[INFO] [stderr]    Compiling rand_core v0.10.1
[INFO] [stderr]    Compiling ciborium-io v0.2.2
[INFO] [stderr]    Compiling bytes v1.12.1
[INFO] [stderr]    Compiling linkme v0.3.37
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]    Compiling bytemuck_derive v1.10.2
[INFO] [stderr]    Compiling zerocopy-derive v0.8.52
[INFO] [stderr]    Compiling thiserror-impl v2.0.18
[INFO] [stderr]     Checking bytemuck v1.25.0
[INFO] [stderr]    Compiling derive_more-impl v2.1.1
[INFO] [stderr]     Checking thiserror v2.0.18
[INFO] [stderr]    Compiling derive-new v0.7.0
[INFO] [stderr]     Checking safe_arch v1.2.0
[INFO] [stderr]    Compiling darling_macro v0.24.1
[INFO] [stderr]    Compiling darling_macro v0.21.3
[INFO] [stderr]    Compiling rustc_apfloat v0.2.3+llvm-462a31f5a5ab
[INFO] [stderr]     Checking fallible-iterator v0.3.0
[INFO] [stderr]     Checking fallible-streaming-iterator v0.1.9
[INFO] [stderr]     Checking futures-lite v2.6.1
[INFO] [stderr]     Checking backtrace v0.3.76
[INFO] [stderr]     Checking toml v1.1.2+spec-1.1.0
[INFO] [stderr]    Compiling darling v0.21.3
[INFO] [stderr]     Checking wide v1.7.0
[INFO] [stderr]    Compiling darling v0.24.1
[INFO] [stderr]    Compiling combine v4.6.8
[INFO] [stderr]     Checking smallvec v1.15.2
[INFO] [stderr]     Checking parking_lot_core v0.9.12
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]     Checking rand v0.10.1
[INFO] [stderr]     Checking async-channel v2.5.0
[INFO] [stderr]    Compiling awint_macros v0.19.0
[INFO] [stderr]     Checking num-bigint v0.4.6
[INFO] [stderr]     Checking serde_bytes v0.11.19
[INFO] [stderr]     Checking nom v8.0.0
[INFO] [stderr]     Checking rusqlite v0.40.2
[INFO] [stderr]    Compiling convert_case v0.11.0
[INFO] [stderr]    Compiling zmij v1.0.21
[INFO] [stderr]     Checking half v2.7.1
[INFO] [stderr]    Compiling cubecl-common v0.11.0-pre.3
[INFO] [stderr]     Checking etcetera v0.11.0
[INFO] [stderr]     Checking embassy-futures v0.1.2
[INFO] [stderr]     Checking foldhash v0.1.5
[INFO] [stderr]     Checking oneshot v0.2.1
[INFO] [stderr]     Checking ciborium-ll v0.2.2
[INFO] [stderr]     Checking rustc-hash v1.1.0
[INFO] [stderr]    Compiling prettyplease v0.3.0
[INFO] [stderr]     Checking ciborium v0.2.2
[INFO] [stderr]    Compiling mutants v0.0.3
[INFO] [stderr]    Compiling portable-atomic v1.15.0
[INFO] [stderr]    Compiling unsynn v0.3.0
[INFO] [stderr]     Checking naga-types v30.0.0
[INFO] [stderr]     Checking float8 v0.7.0
[INFO] [stderr]     Checking hashbrown v0.15.5
[INFO] [stderr]     Checking num-rational v0.4.2
[INFO] [stderr]     Checking derive_more v2.1.1
[INFO] [stderr]     Checking awint v0.19.0
[INFO] [stderr]    Compiling enumset_derive v0.15.0
[INFO] [stderr]     Checking num-iter v0.1.45
[INFO] [stderr]     Checking tynm v0.2.0
[INFO] [stderr]     Checking num-complex v0.4.6
[INFO] [stderr]    Compiling ahash v0.8.12
[INFO] [stderr]     Checking utf8-chars v3.0.7
[INFO] [stderr]    Compiling naga v30.0.0
[INFO] [stderr]    Compiling ash v0.38.0+1.3.281
[INFO] [stderr]     Checking once_vec v0.4.0
[INFO] [stderr]    Compiling pliron-derive v0.17.0
[INFO] [stderr]    Compiling web-time v1.1.0
[INFO] [stderr]     Checking xxhash-rust v0.8.15
[INFO] [stderr]     Checking downcast-rs v2.0.2
[INFO] [stderr]     Checking float4 v0.2.0
[INFO] [stderr]     Checking bit-vec v0.9.1
[INFO] [stderr]     Checking bit-set v0.10.0
[INFO] [stderr]     Checking codespan-reporting v0.13.1
[INFO] [stderr]     Checking enumset v1.1.13
[INFO] [stderr]     Checking num v0.4.3
[INFO] [stderr]    Compiling variadics_please v2.0.0
[INFO] [stderr]     Checking internment v0.8.6
[INFO] [stderr]    Compiling cubecl-macros-internal v0.11.0-pre.3
[INFO] [stderr]     Checking hi_sparse_bitset v0.9.0
[INFO] [stderr]     Checking spirv v0.4.0+sdk-1.4.341.0
[INFO] [stderr]     Checking itertools v0.15.0
[INFO] [stderr]    Compiling wayland-sys v0.31.11
[INFO] [stderr]    Compiling cubecl-runtime v0.11.0-pre.3
[INFO] [stderr]     Checking slab v0.4.12
[INFO] [stderr]     Checking float-ord v0.3.2
[INFO] [stderr]     Checking bumpalo v3.20.3
[INFO] [stderr]    Compiling khronos-egl v6.0.0
[INFO] [stderr]     Checking raw-window-handle v0.6.2
[INFO] [stderr]    Compiling cubecl-macros v0.11.0-pre.3
[INFO] [stderr]     Checking futures-task v0.3.32
[INFO] [stderr]     Checking futures-util v0.3.32
[INFO] [stderr]     Checking wgpu-types v30.0.0
[INFO] [stderr]     Checking cubecl-zspace v0.11.0-pre.3
[INFO] [stderr]     Checking dlib v0.5.3
[INFO] [stderr]     Checking buildid v1.0.5
[INFO] [stderr]    Compiling wgpu-hal v30.0.0
[INFO] [stderr]     Checking presser v0.3.1
[INFO] [stderr]     Checking md5 v0.8.0
[INFO] [stderr]     Checking pliron v0.17.0
[INFO] [stderr]     Checking ordered-float v5.0.0
[INFO] [stderr]     Checking glow v0.17.0
[INFO] [stderr]     Checking profiling v1.0.18
[INFO] [stderr]     Checking renderdoc-sys v1.1.0
[INFO] [stderr]    Compiling wgpu-core v30.0.0
[INFO] [stderr]    Compiling wgpu v30.0.0
[INFO] [stderr]     Checking stable-vec v0.4.2
[INFO] [stderr]    Compiling cubecl-cpp v0.11.0-pre.3
[INFO] [stderr]     Checking sanitize-filename v0.6.0
[INFO] [stderr]     Checking crossbeam-epoch v0.9.18
[INFO] [stderr]    Compiling cubecl-wgpu v0.11.0-pre.3
[INFO] [stderr]    Compiling cubecl v0.11.0-pre.3
[INFO] [stderr]     Checking clap_builder v4.6.0
[INFO] [stderr]     Checking crossbeam-deque v0.8.6
[INFO] [stderr]     Checking itertools v0.10.5
[INFO] [stderr]     Checking rayon-core v1.13.0
[INFO] [stderr]     Checking rayon v1.12.0
[INFO] [stderr]     Checking plotters v0.3.7
[INFO] [stderr]     Checking clap v4.6.1
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking is-terminal v0.4.17
[INFO] [stderr]     Checking criterion-plot v0.5.0
[INFO] [stderr]     Checking criterion v0.5.1
[INFO] [stderr]     Checking cubecl-ir v0.11.0-pre.3
[INFO] [stderr]     Checking wgpu-naga-bridge v30.0.0
[INFO] [stderr]     Checking gpu-allocator v0.28.0
[INFO] [stderr]     Checking wgpu-core-deps-windows-linux-android v30.0.0
[INFO] [stderr]     Checking cubecl-core v0.11.0-pre.3
[INFO] [stderr]     Checking cubecl-opt v0.11.0-pre.3
[INFO] [stderr]     Checking cubecl-std v0.11.0-pre.3
[INFO] [stderr]     Checking massively v0.97.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `<Input as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/api/algorithm/flat_map.rs:18:14
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn apply(input: Input) -> u32 {
[INFO] [stdout]    |              ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 |     fn apply(<<Input as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(input): Input) -> u32 {
[INFO] [stdout]    |              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:285:14
[INFO] [stdout]     |
[INFO] [stdout] 285 |       fn apply(input: RandomU32Args) -> u32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 286 | |         uniform_u32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |_________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomU32Args) -> u32 {
[INFO] [stdout] 286 ~         uniform_u32_value(input.1), input.2, input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:285:14
[INFO] [stdout]     |
[INFO] [stdout] 285 |       fn apply(input: RandomU32Args) -> u32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 286 | |         uniform_u32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |__________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomU32Args) -> u32 {
[INFO] [stdout] 286 ~         uniform_u32_value(input.1, input.2), input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:285:14
[INFO] [stdout]     |
[INFO] [stdout] 285 |       fn apply(input: RandomU32Args) -> u32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 286 | |         uniform_u32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |___________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomU32Args) -> u32 {
[INFO] [stdout] 286 ~         uniform_u32_value(input.1, input.2, input.3), input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:285:14
[INFO] [stdout]     |
[INFO] [stdout] 285 |       fn apply(input: RandomU32Args) -> u32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 286 | |         uniform_u32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomU32Args) -> u32 {
[INFO] [stdout] 286 ~         uniform_u32_value(input.1, input.2, input.3, input.0))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u64>`
[INFO] [stdout]    --> src/api/util/random.rs:294:14
[INFO] [stdout]     |
[INFO] [stdout] 294 |       fn apply(input: RandomU64Args) -> u64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 295 | |         uniform_u64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |_________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 ~     fn apply(<cubecl::frontend::NativeExpand<u64> as Into<_>>::into(input: RandomU64Args) -> u64 {
[INFO] [stdout] 295 ~         uniform_u64_value(input.1), input.2, input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u64>`
[INFO] [stdout]    --> src/api/util/random.rs:294:14
[INFO] [stdout]     |
[INFO] [stdout] 294 |       fn apply(input: RandomU64Args) -> u64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 295 | |         uniform_u64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |__________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 ~     fn apply(<cubecl::frontend::NativeExpand<u64> as Into<_>>::into(input: RandomU64Args) -> u64 {
[INFO] [stdout] 295 ~         uniform_u64_value(input.1, input.2), input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:294:14
[INFO] [stdout]     |
[INFO] [stdout] 294 |       fn apply(input: RandomU64Args) -> u64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 295 | |         uniform_u64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |___________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomU64Args) -> u64 {
[INFO] [stdout] 295 ~         uniform_u64_value(input.1, input.2, input.3), input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:294:14
[INFO] [stdout]     |
[INFO] [stdout] 294 |       fn apply(input: RandomU64Args) -> u64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 295 | |         uniform_u64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomU64Args) -> u64 {
[INFO] [stdout] 295 ~         uniform_u64_value(input.1, input.2, input.3, input.0))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f32>`
[INFO] [stdout]    --> src/api/util/random.rs:303:14
[INFO] [stdout]     |
[INFO] [stdout] 303 |       fn apply(input: RandomF32Args) -> f32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 304 | |         uniform_f32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |_________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 303 ~     fn apply(<cubecl::frontend::NativeExpand<f32> as Into<_>>::into(input: RandomF32Args) -> f32 {
[INFO] [stdout] 304 ~         uniform_f32_value(input.1), input.2, input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f32>`
[INFO] [stdout]    --> src/api/util/random.rs:303:14
[INFO] [stdout]     |
[INFO] [stdout] 303 |       fn apply(input: RandomF32Args) -> f32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 304 | |         uniform_f32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |__________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 303 ~     fn apply(<cubecl::frontend::NativeExpand<f32> as Into<_>>::into(input: RandomF32Args) -> f32 {
[INFO] [stdout] 304 ~         uniform_f32_value(input.1, input.2), input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:303:14
[INFO] [stdout]     |
[INFO] [stdout] 303 |       fn apply(input: RandomF32Args) -> f32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 304 | |         uniform_f32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |___________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 303 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomF32Args) -> f32 {
[INFO] [stdout] 304 ~         uniform_f32_value(input.1, input.2, input.3), input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:303:14
[INFO] [stdout]     |
[INFO] [stdout] 303 |       fn apply(input: RandomF32Args) -> f32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 304 | |         uniform_f32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 303 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomF32Args) -> f32 {
[INFO] [stdout] 304 ~         uniform_f32_value(input.1, input.2, input.3, input.0))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f64>`
[INFO] [stdout]    --> src/api/util/random.rs:312:14
[INFO] [stdout]     |
[INFO] [stdout] 312 |       fn apply(input: RandomF64Args) -> f64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 313 | |         uniform_f64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |_________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 312 ~     fn apply(<cubecl::frontend::NativeExpand<f64> as Into<_>>::into(input: RandomF64Args) -> f64 {
[INFO] [stdout] 313 ~         uniform_f64_value(input.1), input.2, input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f64>`
[INFO] [stdout]    --> src/api/util/random.rs:312:14
[INFO] [stdout]     |
[INFO] [stdout] 312 |       fn apply(input: RandomF64Args) -> f64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 313 | |         uniform_f64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |__________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 312 ~     fn apply(<cubecl::frontend::NativeExpand<f64> as Into<_>>::into(input: RandomF64Args) -> f64 {
[INFO] [stdout] 313 ~         uniform_f64_value(input.1, input.2), input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:312:14
[INFO] [stdout]     |
[INFO] [stdout] 312 |       fn apply(input: RandomF64Args) -> f64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 313 | |         uniform_f64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |___________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 312 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomF64Args) -> f64 {
[INFO] [stdout] 313 ~         uniform_f64_value(input.1, input.2, input.3), input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:312:14
[INFO] [stdout]     |
[INFO] [stdout] 312 |       fn apply(input: RandomF64Args) -> f64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 313 | |         uniform_f64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 312 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomF64Args) -> f64 {
[INFO] [stdout] 313 ~         uniform_f64_value(input.1, input.2, input.3, input.0))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f32>`
[INFO] [stdout]    --> src/api/util/random.rs:321:14
[INFO] [stdout]     |
[INFO] [stdout] 321 |       fn apply(input: RandomF32Args) -> f32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 322 | |         normal_f32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 321 ~     fn apply(<cubecl::frontend::NativeExpand<f32> as Into<_>>::into(input: RandomF32Args) -> f32 {
[INFO] [stdout] 322 ~         normal_f32_value(input.1), input.2, input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f32>`
[INFO] [stdout]    --> src/api/util/random.rs:321:14
[INFO] [stdout]     |
[INFO] [stdout] 321 |       fn apply(input: RandomF32Args) -> f32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 322 | |         normal_f32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |_________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 321 ~     fn apply(<cubecl::frontend::NativeExpand<f32> as Into<_>>::into(input: RandomF32Args) -> f32 {
[INFO] [stdout] 322 ~         normal_f32_value(input.1, input.2), input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:321:14
[INFO] [stdout]     |
[INFO] [stdout] 321 |       fn apply(input: RandomF32Args) -> f32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 322 | |         normal_f32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |__________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 321 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomF32Args) -> f32 {
[INFO] [stdout] 322 ~         normal_f32_value(input.1, input.2, input.3), input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:321:14
[INFO] [stdout]     |
[INFO] [stdout] 321 |       fn apply(input: RandomF32Args) -> f32 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 322 | |         normal_f32_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |___________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 321 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomF32Args) -> f32 {
[INFO] [stdout] 322 ~         normal_f32_value(input.1, input.2, input.3, input.0))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f64>`
[INFO] [stdout]    --> src/api/util/random.rs:330:14
[INFO] [stdout]     |
[INFO] [stdout] 330 |       fn apply(input: RandomF64Args) -> f64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 331 | |         normal_f64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 ~     fn apply(<cubecl::frontend::NativeExpand<f64> as Into<_>>::into(input: RandomF64Args) -> f64 {
[INFO] [stdout] 331 ~         normal_f64_value(input.1), input.2, input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f64>`
[INFO] [stdout]    --> src/api/util/random.rs:330:14
[INFO] [stdout]     |
[INFO] [stdout] 330 |       fn apply(input: RandomF64Args) -> f64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 331 | |         normal_f64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |_________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 ~     fn apply(<cubecl::frontend::NativeExpand<f64> as Into<_>>::into(input: RandomF64Args) -> f64 {
[INFO] [stdout] 331 ~         normal_f64_value(input.1, input.2), input.3, input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:330:14
[INFO] [stdout]     |
[INFO] [stdout] 330 |       fn apply(input: RandomF64Args) -> f64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 331 | |         normal_f64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |__________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomF64Args) -> f64 {
[INFO] [stdout] 331 ~         normal_f64_value(input.1, input.2, input.3), input.0)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:330:14
[INFO] [stdout]     |
[INFO] [stdout] 330 |       fn apply(input: RandomF64Args) -> f64 {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 331 | |         normal_f64_value(input.1, input.2, input.3, input.0)
[INFO] [stdout]     | |___________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 ~     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(input: RandomF64Args) -> f64 {
[INFO] [stdout] 331 ~         normal_f64_value(input.1, input.2, input.3, input.0))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:348:18
[INFO] [stdout]     |
[INFO] [stdout] 348 | fn random_u64_at(key: u32, index: u32, stream: u32) -> u64 {
[INFO] [stdout]     |                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 | fn random_u64_at(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32, stream: u32) -> u64 {
[INFO] [stdout]     |                  +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:348:28
[INFO] [stdout]     |
[INFO] [stdout] 348 | fn random_u64_at(key: u32, index: u32, stream: u32) -> u64 {
[INFO] [stdout]     |                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 | fn random_u64_at(key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32, stream: u32) -> u64 {
[INFO] [stdout]     |                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:348:40
[INFO] [stdout]     |
[INFO] [stdout] 348 | fn random_u64_at(key: u32, index: u32, stream: u32) -> u64 {
[INFO] [stdout]     |                                        ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 | fn random_u64_at(key: u32, index: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(stream): u32) -> u64 {
[INFO] [stdout]     |                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:355:13
[INFO] [stdout]     |
[INFO] [stdout] 355 | fn unit_f32(key: u32, index: u32, stream: u32) -> f32 {
[INFO] [stdout]     |             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 355 | fn unit_f32(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32, stream: u32) -> f32 {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:355:23
[INFO] [stdout]     |
[INFO] [stdout] 355 | fn unit_f32(key: u32, index: u32, stream: u32) -> f32 {
[INFO] [stdout]     |                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 355 | fn unit_f32(key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32, stream: u32) -> f32 {
[INFO] [stdout]     |                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:355:35
[INFO] [stdout]     |
[INFO] [stdout] 355 | fn unit_f32(key: u32, index: u32, stream: u32) -> f32 {
[INFO] [stdout]     |                                   ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 355 | fn unit_f32(key: u32, index: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(stream): u32) -> f32 {
[INFO] [stdout]     |                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:360:13
[INFO] [stdout]     |
[INFO] [stdout] 360 | fn unit_f64(key: u32, index: u32, stream: u32) -> f64 {
[INFO] [stdout]     |             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 | fn unit_f64(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32, stream: u32) -> f64 {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:360:23
[INFO] [stdout]     |
[INFO] [stdout] 360 | fn unit_f64(key: u32, index: u32, stream: u32) -> f64 {
[INFO] [stdout]     |                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 | fn unit_f64(key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32, stream: u32) -> f64 {
[INFO] [stdout]     |                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:360:35
[INFO] [stdout]     |
[INFO] [stdout] 360 | fn unit_f64(key: u32, index: u32, stream: u32) -> f64 {
[INFO] [stdout]     |                                   ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 | fn unit_f64(key: u32, index: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(stream): u32) -> f64 {
[INFO] [stdout]     |                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:365:18
[INFO] [stdout]     |
[INFO] [stdout] 365 | fn open_unit_f32(key: u32, index: u32, stream: u32) -> f32 {
[INFO] [stdout]     |                  ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 365 | fn open_unit_f32(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32, stream: u32) -> f32 {
[INFO] [stdout]     |                  +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:365:28
[INFO] [stdout]     |
[INFO] [stdout] 365 | fn open_unit_f32(key: u32, index: u32, stream: u32) -> f32 {
[INFO] [stdout]     |                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 365 | fn open_unit_f32(key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32, stream: u32) -> f32 {
[INFO] [stdout]     |                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:365:40
[INFO] [stdout]     |
[INFO] [stdout] 365 | fn open_unit_f32(key: u32, index: u32, stream: u32) -> f32 {
[INFO] [stdout]     |                                        ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 365 | fn open_unit_f32(key: u32, index: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(stream): u32) -> f32 {
[INFO] [stdout]     |                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:370:42
[INFO] [stdout]     |
[INFO] [stdout] 370 | fn uniform_f32_value(min: f32, max: f32, key: u32, index: u32) -> f32 {
[INFO] [stdout]     |                                          ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 370 | fn uniform_f32_value(min: f32, max: f32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32) -> f32 {
[INFO] [stdout]     |                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:370:52
[INFO] [stdout]     |
[INFO] [stdout] 370 | fn uniform_f32_value(min: f32, max: f32, key: u32, index: u32) -> f32 {
[INFO] [stdout]     |                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 370 | fn uniform_f32_value(min: f32, max: f32, key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32) -> f32 {
[INFO] [stdout]     |                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:375:42
[INFO] [stdout]     |
[INFO] [stdout] 375 | fn uniform_f64_value(min: f64, max: f64, key: u32, index: u32) -> f64 {
[INFO] [stdout]     |                                          ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 | fn uniform_f64_value(min: f64, max: f64, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32) -> f64 {
[INFO] [stdout]     |                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:375:52
[INFO] [stdout]     |
[INFO] [stdout] 375 | fn uniform_f64_value(min: f64, max: f64, key: u32, index: u32) -> f64 {
[INFO] [stdout]     |                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 | fn uniform_f64_value(min: f64, max: f64, key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32) -> f64 {
[INFO] [stdout]     |                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:380:42
[INFO] [stdout]     |
[INFO] [stdout] 380 | fn uniform_u32_value(min: u32, max: u32, key: u32, index: u32) -> u32 {
[INFO] [stdout]     |                                          ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 | fn uniform_u32_value(min: u32, max: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32) -> u32 {
[INFO] [stdout]     |                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:380:52
[INFO] [stdout]     |
[INFO] [stdout] 380 | fn uniform_u32_value(min: u32, max: u32, key: u32, index: u32) -> u32 {
[INFO] [stdout]     |                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 | fn uniform_u32_value(min: u32, max: u32, key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32) -> u32 {
[INFO] [stdout]     |                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:391:42
[INFO] [stdout]     |
[INFO] [stdout] 391 | fn uniform_u64_value(min: u64, max: u64, key: u32, index: u32) -> u64 {
[INFO] [stdout]     |                                          ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 391 | fn uniform_u64_value(min: u64, max: u64, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32) -> u64 {
[INFO] [stdout]     |                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:391:52
[INFO] [stdout]     |
[INFO] [stdout] 391 | fn uniform_u64_value(min: u64, max: u64, key: u32, index: u32) -> u64 {
[INFO] [stdout]     |                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 391 | fn uniform_u64_value(min: u64, max: u64, key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32) -> u64 {
[INFO] [stdout]     |                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:402:45
[INFO] [stdout]     |
[INFO] [stdout] 402 | fn normal_f32_value(mean: f32, stddev: f32, key: u32, index: u32) -> f32 {
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 | fn normal_f32_value(mean: f32, stddev: f32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32) -> f32 {
[INFO] [stdout]     |                                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:402:55
[INFO] [stdout]     |
[INFO] [stdout] 402 | fn normal_f32_value(mean: f32, stddev: f32, key: u32, index: u32) -> f32 {
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 | fn normal_f32_value(mean: f32, stddev: f32, key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32) -> f32 {
[INFO] [stdout]     |                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:411:45
[INFO] [stdout]     |
[INFO] [stdout] 411 | fn normal_f64_value(mean: f64, stddev: f64, key: u32, index: u32) -> f64 {
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 | fn normal_f64_value(mean: f64, stddev: f64, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(key): u32, index: u32) -> f64 {
[INFO] [stdout]     |                                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/api/util/random.rs:411:55
[INFO] [stdout]     |
[INFO] [stdout] 411 | fn normal_f64_value(mean: f64, stddev: f64, key: u32, index: u32) -> f64 {
[INFO] [stdout]     |                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 | fn normal_f64_value(mean: f64, stddev: f64, key: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(index): u32) -> f64 {
[INFO] [stdout]     |                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:61
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8...
[INFO] [stdout]     |                                                             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0),L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:70
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8...
[INFO] [stdout]     |                                                                      ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1),L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:79
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8...
[INFO] [stdout]     |                                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2),L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:88
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8...
[INFO] [stdout]     |                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3),L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:97
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8...
[INFO] [stdout]     |                                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4),L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:106
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8...
[INFO] [stdout]     |                                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5),L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:115
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8...
[INFO] [stdout]     |                                                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6),L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:124
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8...
[INFO] [stdout]     |                                                                                                                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7),L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:133
[INFO] [stdout]     |
[INFO] [stdout] 372 | ...ot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8),L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:142
[INFO] [stdout]     |
[INFO] [stdout] 372 | ...ot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9),L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:152
[INFO] [stdout]     |
[INFO] [stdout] 372 | ...t3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10),L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:163
[INFO] [stdout]     |
[INFO] [stdout] 372 | ...,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11),L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:372:174
[INFO] [stdout]     |
[INFO] [stdout] 372 | ...6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 | define_arg_reduce_kernel!(arg_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12)]);
[INFO] [stdout]     |                                                                                                                                                                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:63
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0),L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:72
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1),L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:81
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2),L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:90
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3),L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:99
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4),L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:108
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5),L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:117
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6),L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:126
[INFO] [stdout]     |
[INFO] [stdout] 374 | ...ot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7),L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:135
[INFO] [stdout]     |
[INFO] [stdout] 374 | ...ot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8),L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:144
[INFO] [stdout]     |
[INFO] [stdout] 374 | ...ot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9),L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:154
[INFO] [stdout]     |
[INFO] [stdout] 374 | ...t3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10),L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:165
[INFO] [stdout]     |
[INFO] [stdout] 374 | ...,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11),L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/arg_reduce.rs:374:176
[INFO] [stdout]     |
[INFO] [stdout] 374 | ...6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 | define_arg_partial_kernel!(arg_partial_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12)]);
[INFO] [stdout]     |                                                                                                                                                                                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<bool>`
[INFO] [stdout]  --> src/core/collective.rs:8:44
[INFO] [stdout]   |
[INFO] [stdout] 8 | pub(crate) fn plane_digit_rank(digit: u32, valid: bool) -> (u32, u32, u32) {
[INFO] [stdout]   |                                            ^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]   |
[INFO] [stdout] 8 | pub(crate) fn plane_digit_rank(digit: u32, <cubecl::frontend::NativeExpand<bool> as Into<_>>::into(valid): bool) -> (u32, u32, u32) {
[INFO] [stdout]   |                                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<bool>`
[INFO] [stdout]   --> src/core/collective.rs:12:13
[INFO] [stdout]    |
[INFO] [stdout] 12 |         let set = (digit & (1u32 << bit)) != 0u32;
[INFO] [stdout]    |             ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 12 |         let <cubecl::frontend::NativeExpand<bool> as Into<_>>::into(set) = (digit & (1u32 << bit)) != 0u32;
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/core/collective.rs:24:9
[INFO] [stdout]    |
[INFO] [stdout] 24 |     for word in 0usize..4usize {
[INFO] [stdout]    |         ^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 24 |     for <usize as Into<_>>::into(word) in 0usize..4usize {
[INFO] [stdout]    |         +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/collective.rs:50:35
[INFO] [stdout]    |
[INFO] [stdout] 50 | pub(crate) fn block_exclusive_sum(value: u32) -> (u32, u32) {
[INFO] [stdout]    |                                   ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 | pub(crate) fn block_exclusive_sum(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(value): u32) -> (u32, u32) {
[INFO] [stdout]    |                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/core/collective.rs:53:51
[INFO] [stdout]    |
[INFO] [stdout] 53 |     let mut prefixes = Shared::<[u32]>::new_slice(257usize);
[INFO] [stdout]    |                                                   ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 |     let mut prefixes = Shared::<[u32]>::new_slice(<usize as Into<_>>::into(257usize));
[INFO] [stdout]    |                                                   +++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/core/collective.rs:82:5
[INFO] [stdout]    |
[INFO] [stdout] 82 |     width: usize,
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 |     <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(width): usize,
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/core/collective.rs:88:9
[INFO] [stdout]    |
[INFO] [stdout] 88 |     let start = usize::min(UNIT_POS as usize * chunk, width);
[INFO] [stdout]    |         ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(start) = usize::min(UNIT_POS as usize * chunk, width);
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/collective.rs:96:47
[INFO] [stdout]    |
[INFO] [stdout] 96 |     let (prefix, total) = block_exclusive_sum(sum.read());
[INFO] [stdout]    |                                               ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |     let (prefix, total) = block_exclusive_sum(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(sum.read()));
[INFO] [stdout]    |                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/collective.rs:96:10
[INFO] [stdout]    |
[INFO] [stdout] 96 |     let (prefix, total) = block_exclusive_sum(sum.read());
[INFO] [stdout]    |          ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |     let (<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(prefix), total) = block_exclusive_sum(sum.read());
[INFO] [stdout]    |          +++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/eval.rs:416:34
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0), L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/eval.rs:416:45
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1), L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/eval.rs:416:56
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2), L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/eval.rs:416:67
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3), L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/eval.rs:416:78
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                                                              ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4), L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/eval.rs:416:89
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                                                                         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5), L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/eval.rs:416:100
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                                                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6), L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/eval.rs:416:111
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                                                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7), L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/eval.rs:416:122
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9:...
[INFO] [stdout]     |                                                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8), L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/eval.rs:416:133
[INFO] [stdout]     |
[INFO] [stdout] 416 | ..., L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9), L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/eval.rs:416:145
[INFO] [stdout]     |
[INFO] [stdout] 416 | ... L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10), L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                                                                                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/eval.rs:416:158
[INFO] [stdout]     |
[INFO] [stdout] 416 | ...6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11), L12: slot12);
[INFO] [stdout]     |                                                                                                                                                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/eval.rs:416:171
[INFO] [stdout]     |
[INFO] [stdout] 416 | ... slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 | define_eval!(Eval13, eval13; L0: slot0, L1: slot1, L2: slot2, L3: slot3, L4: slot4, L5: slot5, L6: slot6, L7: slot7, L8: slot8, L9: slot9, L10: slot10, L11: slot11, L12: <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12));
[INFO] [stdout]     |                                                                                                                                                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/eval.rs:519:9
[INFO] [stdout]     |
[INFO] [stdout] 519 |         slot0: &[L0],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 519 |         <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0): &[L0],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/eval.rs:520:9
[INFO] [stdout]     |
[INFO] [stdout] 520 |         slot1: &[L1],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 520 |         <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1): &[L1],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/eval.rs:521:9
[INFO] [stdout]     |
[INFO] [stdout] 521 |         slot2: &[L2],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 521 |         <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2): &[L2],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/eval.rs:522:9
[INFO] [stdout]     |
[INFO] [stdout] 522 |         slot3: &[L3],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 522 |         <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3): &[L3],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/eval.rs:523:9
[INFO] [stdout]     |
[INFO] [stdout] 523 |         slot4: &[L4],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 |         <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4): &[L4],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/eval.rs:524:9
[INFO] [stdout]     |
[INFO] [stdout] 524 |         slot5: &[L5],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 524 |         <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5): &[L5],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/eval.rs:525:9
[INFO] [stdout]     |
[INFO] [stdout] 525 |         slot6: &[L6],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 525 |         <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6): &[L6],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/eval.rs:526:9
[INFO] [stdout]     |
[INFO] [stdout] 526 |         slot7: &[L7],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 526 |         <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7): &[L7],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/eval.rs:527:9
[INFO] [stdout]     |
[INFO] [stdout] 527 |         slot8: &[L8],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 527 |         <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8): &[L8],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/eval.rs:528:9
[INFO] [stdout]     |
[INFO] [stdout] 528 |         slot9: &[L9],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 |         <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9): &[L9],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/eval.rs:529:9
[INFO] [stdout]     |
[INFO] [stdout] 529 |         slot10: &[L10],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 529 |         <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10): &[L10],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/eval.rs:530:9
[INFO] [stdout]     |
[INFO] [stdout] 530 |         slot11: &[L11],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 530 |         <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11): &[L11],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/eval.rs:531:9
[INFO] [stdout]     |
[INFO] [stdout] 531 |         slot12: &[L12],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 531 |         <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12): &[L12],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/eval.rs:532:9
[INFO] [stdout]     |
[INFO] [stdout] 532 |         slot_offsets: &[u32],
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 532 |         <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(slot_offsets): &[u32],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:533:9
[INFO] [stdout]     |
[INFO] [stdout] 533 |         offset_base: usize,
[INFO] [stdout]     |         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 533 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(offset_base): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:534:9
[INFO] [stdout]     |
[INFO] [stdout] 534 |         index: usize,
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 534 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<LeftItem as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:536:58
[INFO] [stdout]     |
[INFO] [stdout] 536 |           let left = LeftItem::ReadDeviceLayout::decompose(LeftExpr::eval13_at(
[INFO] [stdout]     |  __________________________________________________________^
[INFO] [stdout] 537 | |             slot0,
[INFO] [stdout] 538 | |             slot1,
[INFO] [stdout] 539 | |             slot2,
[INFO] [stdout] ...   |
[INFO] [stdout] 552 | |             index,
[INFO] [stdout] 553 | |         ));
[INFO] [stdout]     | |_________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 536 ~         let left = LeftItem::ReadDeviceLayout::decompose(<<LeftItem as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(LeftExpr::eval13_at(
[INFO] [stdout] 537 |             slot0,
[INFO] [stdout] ...
[INFO] [stdout] 552 |             index,
[INFO] [stdout] 553 ~         )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<RightItem as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:554:60
[INFO] [stdout]     |
[INFO] [stdout] 554 |           let right = RightItem::ReadDeviceLayout::decompose(RightExpr::eval13_at(
[INFO] [stdout]     |  ____________________________________________________________^
[INFO] [stdout] 555 | |             slot0,
[INFO] [stdout] 556 | |             slot1,
[INFO] [stdout] 557 | |             slot2,
[INFO] [stdout] ...   |
[INFO] [stdout] 570 | |             index,
[INFO] [stdout] 571 | |         ));
[INFO] [stdout]     | |_________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 ~         let right = RightItem::ReadDeviceLayout::decompose(<<RightItem as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(RightExpr::eval13_at(
[INFO] [stdout] 555 |             slot0,
[INFO] [stdout] ...
[INFO] [stdout] 570 |             index,
[INFO] [stdout] 571 ~         )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<RightItem as ReadLayout>::ReadLeaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:554:13
[INFO] [stdout]     |
[INFO] [stdout] 554 |         let right = RightItem::ReadDeviceLayout::decompose(RightExpr::eval13_at(
[INFO] [stdout]     |             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 |         let <<<RightItem as ReadLayout>::ReadLeaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(right) = RightItem::ReadDeviceLayout::decompose(RightExpr::eval13_at(
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<_ as Concat<_>>::Output as CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:574:23
[INFO] [stdout]     |
[INFO] [stdout] 574 |         >>::recompose(left.concat(right))
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: the full name for the type has been written to '/opt/rustwide/target/debug/build/massively/7192a79e079651c8/out/massively-7192a79e079651c8.long-type-6224441962680763914.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 574 |         >>::recompose(<<<<LeftItem as ReadLayout>::ReadLeaves as storage::Concat<<RightItem as ReadLayout>::ReadLeaves>>::Output as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(left.concat(right)))
[INFO] [stdout]     |                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:662:54
[INFO] [stdout]     |
[INFO] [stdout] 662 | impl_unary_eval13_at!(TransformExpr, UnaryOp, input, index; Op::apply(input));
[INFO] [stdout]     |                                                      ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 662 | impl_unary_eval13_at!(TransformExpr, UnaryOp, input, <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index); Op::apply(input));
[INFO] [stdout]     |                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<InputItem as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:662:47
[INFO] [stdout]     |
[INFO] [stdout] 662 | impl_unary_eval13_at!(TransformExpr, UnaryOp, input, index; Op::apply(input));
[INFO] [stdout]     |                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 662 | impl_unary_eval13_at!(TransformExpr, UnaryOp, <<InputItem as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(input), index; Op::apply(input));
[INFO] [stdout]     |                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:663:68
[INFO] [stdout]     |
[INFO] [stdout] 663 | impl_unary_eval13_at!(IndexedTransformExpr, IndexedUnaryOp, input, index; Op::apply(input, index as u32));
[INFO] [stdout]     |                                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 663 | impl_unary_eval13_at!(IndexedTransformExpr, IndexedUnaryOp, input, <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index); Op::apply(input, index as u32));
[INFO] [stdout]     |                                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<InputItem as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:663:61
[INFO] [stdout]     |
[INFO] [stdout] 663 | impl_unary_eval13_at!(IndexedTransformExpr, IndexedUnaryOp, input, index; Op::apply(input, index as u32));
[INFO] [stdout]     |                                                             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 663 | impl_unary_eval13_at!(IndexedTransformExpr, IndexedUnaryOp, <<InputItem as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(input), index; Op::apply(input, index as u32));
[INFO] [stdout]     |                                                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/eval.rs:689:9
[INFO] [stdout]     |
[INFO] [stdout] 689 |         slot0: &[L0],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 689 |         <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0): &[L0],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/eval.rs:690:9
[INFO] [stdout]     |
[INFO] [stdout] 690 |         slot1: &[L1],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 690 |         <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1): &[L1],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/eval.rs:691:9
[INFO] [stdout]     |
[INFO] [stdout] 691 |         slot2: &[L2],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 691 |         <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2): &[L2],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/eval.rs:692:9
[INFO] [stdout]     |
[INFO] [stdout] 692 |         slot3: &[L3],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 692 |         <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3): &[L3],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/eval.rs:693:9
[INFO] [stdout]     |
[INFO] [stdout] 693 |         slot4: &[L4],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 693 |         <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4): &[L4],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/eval.rs:694:9
[INFO] [stdout]     |
[INFO] [stdout] 694 |         slot5: &[L5],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 694 |         <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5): &[L5],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/eval.rs:695:9
[INFO] [stdout]     |
[INFO] [stdout] 695 |         slot6: &[L6],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 |         <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6): &[L6],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/eval.rs:696:9
[INFO] [stdout]     |
[INFO] [stdout] 696 |         slot7: &[L7],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 696 |         <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7): &[L7],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/eval.rs:697:9
[INFO] [stdout]     |
[INFO] [stdout] 697 |         slot8: &[L8],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 697 |         <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8): &[L8],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/eval.rs:698:9
[INFO] [stdout]     |
[INFO] [stdout] 698 |         slot9: &[L9],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 698 |         <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9): &[L9],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/eval.rs:699:9
[INFO] [stdout]     |
[INFO] [stdout] 699 |         slot10: &[L10],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 699 |         <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10): &[L10],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/eval.rs:700:9
[INFO] [stdout]     |
[INFO] [stdout] 700 |         slot11: &[L11],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 700 |         <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11): &[L11],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/eval.rs:701:9
[INFO] [stdout]     |
[INFO] [stdout] 701 |         slot12: &[L12],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 701 |         <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12): &[L12],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/eval.rs:702:9
[INFO] [stdout]     |
[INFO] [stdout] 702 |         slot_offsets: &[u32],
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 702 |         <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(slot_offsets): &[u32],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:703:9
[INFO] [stdout]     |
[INFO] [stdout] 703 |         offset_base: usize,
[INFO] [stdout]     |         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 703 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(offset_base): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:706:13
[INFO] [stdout]     |
[INFO] [stdout] 706 |         let previous_index = if index == 0usize {
[INFO] [stdout]     |             ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 706 |         let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(previous_index) = if index == 0usize {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:704:9
[INFO] [stdout]     |
[INFO] [stdout] 704 |         index: usize,
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 704 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<InputItem as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:711:13
[INFO] [stdout]     |
[INFO] [stdout] 711 |         let previous = InputExpr::eval13_at(
[INFO] [stdout]     |             ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 711 |         let <<InputItem as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(previous) = InputExpr::eval13_at(
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<InputItem as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:729:13
[INFO] [stdout]     |
[INFO] [stdout] 729 |         let current = InputExpr::eval13_at(
[INFO] [stdout]     |             ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 729 |         let <<InputItem as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(current) = InputExpr::eval13_at(
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/eval.rs:776:9
[INFO] [stdout]     |
[INFO] [stdout] 776 |         slot0: &[L0],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 776 |         <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0): &[L0],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/eval.rs:777:9
[INFO] [stdout]     |
[INFO] [stdout] 777 |         slot1: &[L1],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 777 |         <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1): &[L1],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/eval.rs:778:9
[INFO] [stdout]     |
[INFO] [stdout] 778 |         slot2: &[L2],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 778 |         <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2): &[L2],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/eval.rs:779:9
[INFO] [stdout]     |
[INFO] [stdout] 779 |         slot3: &[L3],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 779 |         <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3): &[L3],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/eval.rs:780:9
[INFO] [stdout]     |
[INFO] [stdout] 780 |         slot4: &[L4],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 780 |         <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4): &[L4],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/eval.rs:781:9
[INFO] [stdout]     |
[INFO] [stdout] 781 |         slot5: &[L5],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 781 |         <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5): &[L5],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/eval.rs:782:9
[INFO] [stdout]     |
[INFO] [stdout] 782 |         slot6: &[L6],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 782 |         <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6): &[L6],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/eval.rs:783:9
[INFO] [stdout]     |
[INFO] [stdout] 783 |         slot7: &[L7],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 783 |         <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7): &[L7],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/eval.rs:784:9
[INFO] [stdout]     |
[INFO] [stdout] 784 |         slot8: &[L8],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 784 |         <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8): &[L8],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/eval.rs:785:9
[INFO] [stdout]     |
[INFO] [stdout] 785 |         slot9: &[L9],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 785 |         <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9): &[L9],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/eval.rs:786:9
[INFO] [stdout]     |
[INFO] [stdout] 786 |         slot10: &[L10],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 786 |         <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10): &[L10],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/eval.rs:787:9
[INFO] [stdout]     |
[INFO] [stdout] 787 |         slot11: &[L11],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 787 |         <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11): &[L11],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/eval.rs:788:9
[INFO] [stdout]     |
[INFO] [stdout] 788 |         slot12: &[L12],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 788 |         <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12): &[L12],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/eval.rs:789:9
[INFO] [stdout]     |
[INFO] [stdout] 789 |         slot_offsets: &[u32],
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 789 |         <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(slot_offsets): &[u32],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:790:9
[INFO] [stdout]     |
[INFO] [stdout] 790 |         offset_base: usize,
[INFO] [stdout]     |         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 790 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(offset_base): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:791:9
[INFO] [stdout]     |
[INFO] [stdout] 791 |         index: usize,
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 791 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:798:39
[INFO] [stdout]     |
[INFO] [stdout] 798 |           let first = Layout::decompose(InputExpr::eval13_at(
[INFO] [stdout]     |  _______________________________________^
[INFO] [stdout] 799 | |             slot0,
[INFO] [stdout] 800 | |             slot1,
[INFO] [stdout] 801 | |             slot2,
[INFO] [stdout] ...   |
[INFO] [stdout] 814 | |             index,
[INFO] [stdout] 815 | |         ));
[INFO] [stdout]     | |_________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 798 ~         let first = Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(InputExpr::eval13_at(
[INFO] [stdout] 799 |             slot0,
[INFO] [stdout] ...
[INFO] [stdout] 814 |             index,
[INFO] [stdout] 815 ~         )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:793:13
[INFO] [stdout]     |
[INFO] [stdout] 793 |         let previous_index = if index == 0usize {
[INFO] [stdout]     |             ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 793 |         let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(previous_index) = if index == 0usize {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:817:13
[INFO] [stdout]     |
[INFO] [stdout] 817 | /             InputExpr::eval13_at(
[INFO] [stdout] 818 | |                 slot0,
[INFO] [stdout] 819 | |                 slot1,
[INFO] [stdout] 820 | |                 slot2,
[INFO] [stdout] ...   |
[INFO] [stdout] 833 | |                 previous_index,
[INFO] [stdout] 834 | |             ),
[INFO] [stdout]     | |_____________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 817 ~             <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(InputExpr::eval13_at(
[INFO] [stdout] 818 |                 slot0,
[INFO] [stdout] ...
[INFO] [stdout] 833 |                 previous_index,
[INFO] [stdout] 834 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:835:13
[INFO] [stdout]     |
[INFO] [stdout] 835 | /             InputExpr::eval13_at(
[INFO] [stdout] 836 | |                 slot0,
[INFO] [stdout] 837 | |                 slot1,
[INFO] [stdout] 838 | |                 slot2,
[INFO] [stdout] ...   |
[INFO] [stdout] 851 | |                 index,
[INFO] [stdout] 852 | |             ),
[INFO] [stdout]     | |_____________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 835 ~             <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(InputExpr::eval13_at(
[INFO] [stdout] 836 |                 slot0,
[INFO] [stdout] ...
[INFO] [stdout] 851 |                 index,
[INFO] [stdout] 852 ~             )),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:816:42
[INFO] [stdout]     |
[INFO] [stdout] 816 |           let adjacent = Layout::decompose(Op::apply(
[INFO] [stdout]     |  __________________________________________^
[INFO] [stdout] 817 | |             InputExpr::eval13_at(
[INFO] [stdout] 818 | |                 slot0,
[INFO] [stdout] 819 | |                 slot1,
[INFO] [stdout] ...   |
[INFO] [stdout] 852 | |             ),
[INFO] [stdout] 853 | |         ));
[INFO] [stdout]     | |_________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 816 ~         let adjacent = Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Op::apply(
[INFO] [stdout] 817 |             InputExpr::eval13_at(
[INFO] [stdout] ...
[INFO] [stdout] 852 |             ),
[INFO] [stdout] 853 ~         )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:798:13
[INFO] [stdout]     |
[INFO] [stdout] 798 |         let first = Layout::decompose(InputExpr::eval13_at(
[INFO] [stdout]     |             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 798 |         let <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(first) = Layout::decompose(InputExpr::eval13_at(
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:816:13
[INFO] [stdout]     |
[INFO] [stdout] 816 |         let adjacent = Layout::decompose(Op::apply(
[INFO] [stdout]     |             ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 816 |         let <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(adjacent) = Layout::decompose(Op::apply(
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/eval.rs:854:27
[INFO] [stdout]     |
[INFO] [stdout] 854 |         Layout::recompose(Leaves::select(index == 0usize, first, adjacent))
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 854 |         Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::select(index == 0usize, first, adjacent)))
[INFO] [stdout]     |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/eval.rs:881:9
[INFO] [stdout]     |
[INFO] [stdout] 881 |         slot0: &[L0],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 881 |         <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0): &[L0],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/eval.rs:882:9
[INFO] [stdout]     |
[INFO] [stdout] 882 |         slot1: &[L1],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 882 |         <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1): &[L1],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/eval.rs:883:9
[INFO] [stdout]     |
[INFO] [stdout] 883 |         slot2: &[L2],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 883 |         <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2): &[L2],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/eval.rs:884:9
[INFO] [stdout]     |
[INFO] [stdout] 884 |         slot3: &[L3],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 884 |         <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3): &[L3],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/eval.rs:885:9
[INFO] [stdout]     |
[INFO] [stdout] 885 |         slot4: &[L4],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 885 |         <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4): &[L4],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/eval.rs:886:9
[INFO] [stdout]     |
[INFO] [stdout] 886 |         slot5: &[L5],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 |         <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5): &[L5],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/eval.rs:887:9
[INFO] [stdout]     |
[INFO] [stdout] 887 |         slot6: &[L6],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 887 |         <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6): &[L6],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/eval.rs:888:9
[INFO] [stdout]     |
[INFO] [stdout] 888 |         slot7: &[L7],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 888 |         <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7): &[L7],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/eval.rs:889:9
[INFO] [stdout]     |
[INFO] [stdout] 889 |         slot8: &[L8],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 889 |         <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8): &[L8],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/eval.rs:890:9
[INFO] [stdout]     |
[INFO] [stdout] 890 |         slot9: &[L9],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 890 |         <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9): &[L9],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/eval.rs:891:9
[INFO] [stdout]     |
[INFO] [stdout] 891 |         slot10: &[L10],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 891 |         <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10): &[L10],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/eval.rs:892:9
[INFO] [stdout]     |
[INFO] [stdout] 892 |         slot11: &[L11],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 892 |         <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11): &[L11],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/eval.rs:893:9
[INFO] [stdout]     |
[INFO] [stdout] 893 |         slot12: &[L12],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 893 |         <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12): &[L12],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/eval.rs:894:9
[INFO] [stdout]     |
[INFO] [stdout] 894 |         slot_offsets: &[u32],
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 894 |         <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(slot_offsets): &[u32],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:895:9
[INFO] [stdout]     |
[INFO] [stdout] 895 |         offset_base: usize,
[INFO] [stdout]     |         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 895 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(offset_base): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:896:9
[INFO] [stdout]     |
[INFO] [stdout] 896 |         index: usize,
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 896 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/eval.rs:958:9
[INFO] [stdout]     |
[INFO] [stdout] 958 |         slot0: &[L0],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 958 |         <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0): &[L0],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/eval.rs:959:9
[INFO] [stdout]     |
[INFO] [stdout] 959 |         slot1: &[L1],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 959 |         <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1): &[L1],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/eval.rs:960:9
[INFO] [stdout]     |
[INFO] [stdout] 960 |         slot2: &[L2],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 960 |         <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2): &[L2],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/eval.rs:961:9
[INFO] [stdout]     |
[INFO] [stdout] 961 |         slot3: &[L3],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 961 |         <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3): &[L3],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/eval.rs:962:9
[INFO] [stdout]     |
[INFO] [stdout] 962 |         slot4: &[L4],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 962 |         <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4): &[L4],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/eval.rs:963:9
[INFO] [stdout]     |
[INFO] [stdout] 963 |         slot5: &[L5],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 963 |         <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5): &[L5],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/eval.rs:964:9
[INFO] [stdout]     |
[INFO] [stdout] 964 |         slot6: &[L6],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 964 |         <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6): &[L6],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/eval.rs:965:9
[INFO] [stdout]     |
[INFO] [stdout] 965 |         slot7: &[L7],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 965 |         <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7): &[L7],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/eval.rs:966:9
[INFO] [stdout]     |
[INFO] [stdout] 966 |         slot8: &[L8],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 966 |         <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8): &[L8],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/eval.rs:967:9
[INFO] [stdout]     |
[INFO] [stdout] 967 |         slot9: &[L9],
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 967 |         <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9): &[L9],
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/eval.rs:968:9
[INFO] [stdout]     |
[INFO] [stdout] 968 |         slot10: &[L10],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 968 |         <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10): &[L10],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/eval.rs:969:9
[INFO] [stdout]     |
[INFO] [stdout] 969 |         slot11: &[L11],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 969 |         <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11): &[L11],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/eval.rs:970:9
[INFO] [stdout]     |
[INFO] [stdout] 970 |         slot12: &[L12],
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 970 |         <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12): &[L12],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/eval.rs:971:9
[INFO] [stdout]     |
[INFO] [stdout] 971 |         slot_offsets: &[u32],
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 971 |         <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(slot_offsets): &[u32],
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/eval.rs:972:9
[INFO] [stdout]     |
[INFO] [stdout] 972 |         offset_base: usize,
[INFO] [stdout]     |         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 972 |         <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(offset_base): usize,
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1235:156
[INFO] [stdout]      |
[INFO] [stdout] 1235 | ...2>; [T, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slo...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1235 | impl_slot_eval!(Eval13, eval13, Slot0, 0; <T, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12>; [T, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [<&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot0), slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot0);
[INFO] [stdout]      |                                                                                                                                                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1236:163
[INFO] [stdout]      |
[INFO] [stdout] 1236 | ..., T, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slo...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1236 | impl_slot_eval!(Eval13, eval13, Slot1, 1; <L0, T, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12>; [L0, T, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot1), slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot1);
[INFO] [stdout]      |                                                                                                                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1237:170
[INFO] [stdout]      |
[INFO] [stdout] 1237 | ..., L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, sl...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1237 | impl_slot_eval!(Eval13, eval13, Slot2, 2; <L0, L1, T, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12>; [L0, L1, T, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot2), slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot2);
[INFO] [stdout]      |                                                                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1238:177
[INFO] [stdout]      |
[INFO] [stdout] 1238 | ...4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, s...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1238 | impl_slot_eval!(Eval13, eval13, Slot3, 3; <L0, L1, L2, T, L4, L5, L6, L7, L8, L9, L10, L11, L12>; [L0, L1, L2, T, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot3), slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot3);
[INFO] [stdout]      |                                                                                                                                                                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1239:184
[INFO] [stdout]      |
[INFO] [stdout] 1239 | ...L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12];...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1239 | impl_slot_eval!(Eval13, eval13, Slot4, 4; <L0, L1, L2, L3, T, L5, L6, L7, L8, L9, L10, L11, L12>; [L0, L1, L2, L3, T, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot4), slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot4);
[INFO] [stdout]      |                                                                                                                                                                                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1240:191
[INFO] [stdout]      |
[INFO] [stdout] 1240 | ... L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot5);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1240 | impl_slot_eval!(Eval13, eval13, Slot5, 5; <L0, L1, L2, L3, L4, T, L6, L7, L8, L9, L10, L11, L12>; [L0, L1, L2, L3, L4, T, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot5), slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot5);
[INFO] [stdout]      |                                                                                                                                                                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1241:198
[INFO] [stdout]      |
[INFO] [stdout] 1241 | ..., L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot6);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1241 | impl_slot_eval!(Eval13, eval13, Slot6, 6; <L0, L1, L2, L3, L4, L5, T, L7, L8, L9, L10, L11, L12>; [L0, L1, L2, L3, L4, L5, T, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot6), slot7, slot8, slot9, slot10, slot11, slot12]; slot6);
[INFO] [stdout]      |                                                                                                                                                                                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1242:205
[INFO] [stdout]      |
[INFO] [stdout] 1242 | ...L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot7);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1242 | impl_slot_eval!(Eval13, eval13, Slot7, 7; <L0, L1, L2, L3, L4, L5, L6, T, L8, L9, L10, L11, L12>; [L0, L1, L2, L3, L4, L5, L6, T, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot7), slot8, slot9, slot10, slot11, slot12]; slot7);
[INFO] [stdout]      |                                                                                                                                                                                                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1243:212
[INFO] [stdout]      |
[INFO] [stdout] 1243 | ...2]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot8);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1243 | impl_slot_eval!(Eval13, eval13, Slot8, 8; <L0, L1, L2, L3, L4, L5, L6, L7, T, L9, L10, L11, L12>; [L0, L1, L2, L3, L4, L5, L6, L7, T, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot8), slot9, slot10, slot11, slot12]; slot8);
[INFO] [stdout]      |                                                                                                                                                                                                                    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1244:219
[INFO] [stdout]      |
[INFO] [stdout] 1244 | ...ot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot9);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1244 | impl_slot_eval!(Eval13, eval13, Slot9, 9; <L0, L1, L2, L3, L4, L5, L6, L7, L8, T, L10, L11, L12>; [L0, L1, L2, L3, L4, L5, L6, L7, L8, T, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot9), slot10, slot11, slot12]; slot9);
[INFO] [stdout]      |                                                                                                                                                                                                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1245:226
[INFO] [stdout]      |
[INFO] [stdout] 1245 | ...t1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot10);
[INFO] [stdout]      |                                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1245 | impl_slot_eval!(Eval13, eval13, Slot10, 10; <L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, T, L11, L12>; [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, T, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot10), slot11, slot12]; slot10);
[INFO] [stdout]      |                                                                                                                                                                                                                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1246:234
[INFO] [stdout]      |
[INFO] [stdout] 1246 | ...2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot11);
[INFO] [stdout]      |                                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1246 | impl_slot_eval!(Eval13, eval13, Slot11, 11; <L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, T, L12>; [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, T, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot11), slot12]; slot11);
[INFO] [stdout]      |                                                                                                                                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1247:242
[INFO] [stdout]      |
[INFO] [stdout] 1247 | ..., slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot12);
[INFO] [stdout]      |                                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1247 | impl_slot_eval!(Eval13, eval13, Slot12, 12; <L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, T>; [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, T]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot12)]; slot12);
[INFO] [stdout]      |                                                                                                                                                                                                                                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1276:145
[INFO] [stdout]      |
[INFO] [stdout] 1276 | ...2>; [T, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slo...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1276 | impl_slot_eval13_at!(Slot0, 0; <T, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12>; [T, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [<&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot0), slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot0);
[INFO] [stdout]      |                                                                                                                                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1277:152
[INFO] [stdout]      |
[INFO] [stdout] 1277 | ..., T, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slo...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1277 | impl_slot_eval13_at!(Slot1, 1; <L0, T, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12>; [L0, T, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot1), slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot1);
[INFO] [stdout]      |                                                                                                                                                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1278:159
[INFO] [stdout]      |
[INFO] [stdout] 1278 | ..., L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, sl...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1278 | impl_slot_eval13_at!(Slot2, 2; <L0, L1, T, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12>; [L0, L1, T, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot2), slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot2);
[INFO] [stdout]      |                                                                                                                                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1279:166
[INFO] [stdout]      |
[INFO] [stdout] 1279 | ...4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, s...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1279 | impl_slot_eval13_at!(Slot3, 3; <L0, L1, L2, T, L4, L5, L6, L7, L8, L9, L10, L11, L12>; [L0, L1, L2, T, L4, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot3), slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot3);
[INFO] [stdout]      |                                                                                                                                                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1280:173
[INFO] [stdout]      |
[INFO] [stdout] 1280 | ...L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12];...
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1280 | impl_slot_eval13_at!(Slot4, 4; <L0, L1, L2, L3, T, L5, L6, L7, L8, L9, L10, L11, L12>; [L0, L1, L2, L3, T, L5, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot4), slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot4);
[INFO] [stdout]      |                                                                                                                                                                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1281:180
[INFO] [stdout]      |
[INFO] [stdout] 1281 | ... L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot5);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1281 | impl_slot_eval13_at!(Slot5, 5; <L0, L1, L2, L3, L4, T, L6, L7, L8, L9, L10, L11, L12>; [L0, L1, L2, L3, L4, T, L6, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot5), slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot5);
[INFO] [stdout]      |                                                                                                                                                                                    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1282:187
[INFO] [stdout]      |
[INFO] [stdout] 1282 | ..., L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot6);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1282 | impl_slot_eval13_at!(Slot6, 6; <L0, L1, L2, L3, L4, L5, T, L7, L8, L9, L10, L11, L12>; [L0, L1, L2, L3, L4, L5, T, L7, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot6), slot7, slot8, slot9, slot10, slot11, slot12]; slot6);
[INFO] [stdout]      |                                                                                                                                                                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1283:194
[INFO] [stdout]      |
[INFO] [stdout] 1283 | ...L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot7);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1283 | impl_slot_eval13_at!(Slot7, 7; <L0, L1, L2, L3, L4, L5, L6, T, L8, L9, L10, L11, L12>; [L0, L1, L2, L3, L4, L5, L6, T, L8, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot7), slot8, slot9, slot10, slot11, slot12]; slot7);
[INFO] [stdout]      |                                                                                                                                                                                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1284:201
[INFO] [stdout]      |
[INFO] [stdout] 1284 | ...2]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot8);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1284 | impl_slot_eval13_at!(Slot8, 8; <L0, L1, L2, L3, L4, L5, L6, L7, T, L9, L10, L11, L12>; [L0, L1, L2, L3, L4, L5, L6, L7, T, L9, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot8), slot9, slot10, slot11, slot12]; slot8);
[INFO] [stdout]      |                                                                                                                                                                                                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1285:208
[INFO] [stdout]      |
[INFO] [stdout] 1285 | ...ot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot9);
[INFO] [stdout]      |                                                                 ^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1285 | impl_slot_eval13_at!(Slot9, 9; <L0, L1, L2, L3, L4, L5, L6, L7, L8, T, L10, L11, L12>; [L0, L1, L2, L3, L4, L5, L6, L7, L8, T, L10, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot9), slot10, slot11, slot12]; slot9);
[INFO] [stdout]      |                                                                                                                                                                                                                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1286:215
[INFO] [stdout]      |
[INFO] [stdout] 1286 | ...t1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot10);
[INFO] [stdout]      |                                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1286 | impl_slot_eval13_at!(Slot10, 10; <L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, T, L11, L12>; [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, T, L11, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot10), slot11, slot12]; slot10);
[INFO] [stdout]      |                                                                                                                                                                                                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1287:223
[INFO] [stdout]      |
[INFO] [stdout] 1287 | ...2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot11);
[INFO] [stdout]      |                                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1287 | impl_slot_eval13_at!(Slot11, 11; <L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, T, L12>; [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, T, L12]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot11), slot12]; slot11);
[INFO] [stdout]      |                                                                                                                                                                                                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[T]>`
[INFO] [stdout]     --> src/core/eval.rs:1288:231
[INFO] [stdout]      |
[INFO] [stdout] 1288 | ..., slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, slot12]; slot12);
[INFO] [stdout]      |                                                                ^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1288 | impl_slot_eval13_at!(Slot12, 12; <L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, T>; [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, T]; [slot0, slot1, slot2, slot3, slot4, slot5, slot6, slot7, slot8, slot9, slot10, slot11, <&cubecl::frontend::NativeExpand<[T]> as Into<_>>::into(slot12)]; slot12);
[INFO] [stdout]      |                                                                                                                                                                                                                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]   --> src/core/expansion.rs:83:5
[INFO] [stdout]    |
[INFO] [stdout] 83 |     slot0: &[L0],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 |     <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0): &[L0],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]   --> src/core/expansion.rs:84:5
[INFO] [stdout]    |
[INFO] [stdout] 84 |     slot1: &[L1],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |     <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1): &[L1],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]   --> src/core/expansion.rs:85:5
[INFO] [stdout]    |
[INFO] [stdout] 85 |     slot2: &[L2],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 |     <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2): &[L2],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]   --> src/core/expansion.rs:86:5
[INFO] [stdout]    |
[INFO] [stdout] 86 |     slot3: &[L3],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 86 |     <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3): &[L3],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]   --> src/core/expansion.rs:87:5
[INFO] [stdout]    |
[INFO] [stdout] 87 |     slot4: &[L4],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 |     <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4): &[L4],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]   --> src/core/expansion.rs:88:5
[INFO] [stdout]    |
[INFO] [stdout] 88 |     slot5: &[L5],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |     <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5): &[L5],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]   --> src/core/expansion.rs:89:5
[INFO] [stdout]    |
[INFO] [stdout] 89 |     slot6: &[L6],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 |     <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6): &[L6],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]   --> src/core/expansion.rs:90:5
[INFO] [stdout]    |
[INFO] [stdout] 90 |     slot7: &[L7],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 90 |     <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7): &[L7],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]   --> src/core/expansion.rs:91:5
[INFO] [stdout]    |
[INFO] [stdout] 91 |     slot8: &[L8],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 |     <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8): &[L8],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]   --> src/core/expansion.rs:92:5
[INFO] [stdout]    |
[INFO] [stdout] 92 |     slot9: &[L9],
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 92 |     <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9): &[L9],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]   --> src/core/expansion.rs:93:5
[INFO] [stdout]    |
[INFO] [stdout] 93 |     slot10: &[L10],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |     <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10): &[L10],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]   --> src/core/expansion.rs:94:5
[INFO] [stdout]    |
[INFO] [stdout] 94 |     slot11: &[L11],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 |     <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11): &[L11],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]   --> src/core/expansion.rs:95:5
[INFO] [stdout]    |
[INFO] [stdout] 95 |     slot12: &[L12],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 |     <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12): &[L12],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]   --> src/core/expansion.rs:96:5
[INFO] [stdout]    |
[INFO] [stdout] 96 |     read_offsets: &[u32],
[INFO] [stdout]    |     ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(read_offsets): &[u32],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/expansion.rs:115:13
[INFO] [stdout]     |
[INFO] [stdout] 115 |         let input_index = resolved[base] as usize;
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 115 |         let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(input_index) = resolved[base] as usize;
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<InputItem as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/expansion.rs:117:13
[INFO] [stdout]     |
[INFO] [stdout] 117 |         let input = Expr::eval13(
[INFO] [stdout]     |             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 117 |         let <<InputItem as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(input) = Expr::eval13(
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/expansion.rs:116:13
[INFO] [stdout]     |
[INFO] [stdout] 116 |         let local_index = resolved[base + 1usize];
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 |         let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(local_index) = resolved[base + 1usize];
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<OutputItem as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/expansion.rs:134:27
[INFO] [stdout]     |
[INFO] [stdout] 134 |         Layout::decompose(Op::generate(input, local_index)).store_padded(
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 134 |         Layout::decompose(<<OutputItem as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Op::generate(input, local_index))).store_padded(
[INFO] [stdout]     |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]   --> src/core/expansion.rs:98:5
[INFO] [stdout]    |
[INFO] [stdout] 98 |     out0: &mut [O0],
[INFO] [stdout]    |     ^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 |     <&mut cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(out0): &mut [O0],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]   --> src/core/expansion.rs:99:5
[INFO] [stdout]    |
[INFO] [stdout] 99 |     out1: &mut [O1],
[INFO] [stdout]    |     ^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 |     <&mut cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(out1): &mut [O1],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/expansion.rs:100:5
[INFO] [stdout]     |
[INFO] [stdout] 100 |     out2: &mut [O2],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 |     <&mut cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(out2): &mut [O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/expansion.rs:101:5
[INFO] [stdout]     |
[INFO] [stdout] 101 |     out3: &mut [O3],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 101 |     <&mut cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(out3): &mut [O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/expansion.rs:102:5
[INFO] [stdout]     |
[INFO] [stdout] 102 |     out4: &mut [O4],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 102 |     <&mut cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(out4): &mut [O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/expansion.rs:103:5
[INFO] [stdout]     |
[INFO] [stdout] 103 |     out5: &mut [O5],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 |     <&mut cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(out5): &mut [O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/expansion.rs:104:5
[INFO] [stdout]     |
[INFO] [stdout] 104 |     out6: &mut [O6],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 |     <&mut cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(out6): &mut [O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/expansion.rs:105:5
[INFO] [stdout]     |
[INFO] [stdout] 105 |     out7: &mut [O7],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 105 |     <&mut cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(out7): &mut [O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/expansion.rs:106:5
[INFO] [stdout]     |
[INFO] [stdout] 106 |     out8: &mut [O8],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 |     <&mut cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(out8): &mut [O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/expansion.rs:107:5
[INFO] [stdout]     |
[INFO] [stdout] 107 |     out9: &mut [O9],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 107 |     <&mut cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(out9): &mut [O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/expansion.rs:108:5
[INFO] [stdout]     |
[INFO] [stdout] 108 |     out10: &mut [O10],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 108 |     <&mut cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(out10): &mut [O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/expansion.rs:109:5
[INFO] [stdout]     |
[INFO] [stdout] 109 |     out11: &mut [O11],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 109 |     <&mut cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(out11): &mut [O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/expansion.rs:110:5
[INFO] [stdout]     |
[INFO] [stdout] 110 |     write_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(write_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/expansion.rs:112:9
[INFO] [stdout]     |
[INFO] [stdout] 112 |     let output_index = ABSOLUTE_POS as usize;
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 112 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(output_index) = ABSOLUTE_POS as usize;
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/extent.rs:66:13
[INFO] [stdout]    |
[INFO] [stdout] 66 |         let start = parameters[0];
[INFO] [stdout]    |             ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |         let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(start) = parameters[0];
[INFO] [stdout]    |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/extent.rs:69:13
[INFO] [stdout]    |
[INFO] [stdout] 69 |         let remaining = source_len.saturating_sub(start);
[INFO] [stdout]    |             ^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 |         let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(remaining) = source_len.saturating_sub(start);
[INFO] [stdout]    |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/extent.rs:67:13
[INFO] [stdout]    |
[INFO] [stdout] 67 |         let limit = parameters[1];
[INFO] [stdout]    |             ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |         let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(limit) = parameters[1];
[INFO] [stdout]    |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/core/indexed.rs:70:9
[INFO] [stdout]    |
[INFO] [stdout] 70 |     let dispatch_position = ABSOLUTE_POS as usize;
[INFO] [stdout]    |         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(dispatch_position) = ABSOLUTE_POS as usize;
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]   --> src/core/indexed.rs:63:5
[INFO] [stdout]    |
[INFO] [stdout] 63 |     selection_route: &[u32],
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(selection_route): &[u32],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]   --> src/core/indexed.rs:64:5
[INFO] [stdout]    |
[INFO] [stdout] 64 |     selection_block_prefixes: &[u32],
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 64 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(selection_block_prefixes): &[u32],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<bool>`
[INFO] [stdout]   --> src/core/indexed.rs:90:24
[INFO] [stdout]    |
[INFO] [stdout] 90 |             let (rank, selected) = crate::core::selection::route_rank_before(
[INFO] [stdout]    |                        ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 90 |             let (rank, <cubecl::frontend::NativeExpand<bool> as Into<_>>::into(selected)) = crate::core::selection::route_rank_before(
[INFO] [stdout]    |                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I0]>`
[INFO] [stdout]   --> src/core/indexed.rs:49:5
[INFO] [stdout]    |
[INFO] [stdout] 49 |     index_slot0: &[I0],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 49 |     <&cubecl::frontend::NativeExpand<[I0]> as Into<_>>::into(index_slot0): &[I0],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I1]>`
[INFO] [stdout]   --> src/core/indexed.rs:50:5
[INFO] [stdout]    |
[INFO] [stdout] 50 |     index_slot1: &[I1],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 |     <&cubecl::frontend::NativeExpand<[I1]> as Into<_>>::into(index_slot1): &[I1],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I2]>`
[INFO] [stdout]   --> src/core/indexed.rs:51:5
[INFO] [stdout]    |
[INFO] [stdout] 51 |     index_slot2: &[I2],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 |     <&cubecl::frontend::NativeExpand<[I2]> as Into<_>>::into(index_slot2): &[I2],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I3]>`
[INFO] [stdout]   --> src/core/indexed.rs:52:5
[INFO] [stdout]    |
[INFO] [stdout] 52 |     index_slot3: &[I3],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 |     <&cubecl::frontend::NativeExpand<[I3]> as Into<_>>::into(index_slot3): &[I3],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I4]>`
[INFO] [stdout]   --> src/core/indexed.rs:53:5
[INFO] [stdout]    |
[INFO] [stdout] 53 |     index_slot4: &[I4],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 |     <&cubecl::frontend::NativeExpand<[I4]> as Into<_>>::into(index_slot4): &[I4],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I5]>`
[INFO] [stdout]   --> src/core/indexed.rs:54:5
[INFO] [stdout]    |
[INFO] [stdout] 54 |     index_slot5: &[I5],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |     <&cubecl::frontend::NativeExpand<[I5]> as Into<_>>::into(index_slot5): &[I5],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I6]>`
[INFO] [stdout]   --> src/core/indexed.rs:55:5
[INFO] [stdout]    |
[INFO] [stdout] 55 |     index_slot6: &[I6],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 |     <&cubecl::frontend::NativeExpand<[I6]> as Into<_>>::into(index_slot6): &[I6],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I7]>`
[INFO] [stdout]   --> src/core/indexed.rs:56:5
[INFO] [stdout]    |
[INFO] [stdout] 56 |     index_slot7: &[I7],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 56 |     <&cubecl::frontend::NativeExpand<[I7]> as Into<_>>::into(index_slot7): &[I7],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I8]>`
[INFO] [stdout]   --> src/core/indexed.rs:57:5
[INFO] [stdout]    |
[INFO] [stdout] 57 |     index_slot8: &[I8],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 |     <&cubecl::frontend::NativeExpand<[I8]> as Into<_>>::into(index_slot8): &[I8],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I9]>`
[INFO] [stdout]   --> src/core/indexed.rs:58:5
[INFO] [stdout]    |
[INFO] [stdout] 58 |     index_slot9: &[I9],
[INFO] [stdout]    |     ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 |     <&cubecl::frontend::NativeExpand<[I9]> as Into<_>>::into(index_slot9): &[I9],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I10]>`
[INFO] [stdout]   --> src/core/indexed.rs:59:5
[INFO] [stdout]    |
[INFO] [stdout] 59 |     index_slot10: &[I10],
[INFO] [stdout]    |     ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |     <&cubecl::frontend::NativeExpand<[I10]> as Into<_>>::into(index_slot10): &[I10],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I11]>`
[INFO] [stdout]   --> src/core/indexed.rs:60:5
[INFO] [stdout]    |
[INFO] [stdout] 60 |     index_slot11: &[I11],
[INFO] [stdout]    |     ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 |     <&cubecl::frontend::NativeExpand<[I11]> as Into<_>>::into(index_slot11): &[I11],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I12]>`
[INFO] [stdout]   --> src/core/indexed.rs:61:5
[INFO] [stdout]    |
[INFO] [stdout] 61 |     index_slot12: &[I12],
[INFO] [stdout]    |     ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 |     <&cubecl::frontend::NativeExpand<[I12]> as Into<_>>::into(index_slot12): &[I12],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]   --> src/core/indexed.rs:62:5
[INFO] [stdout]    |
[INFO] [stdout] 62 |     index_offsets: &[u32],
[INFO] [stdout]    |     ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(index_offsets): &[u32],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/indexed.rs:105:13
[INFO] [stdout]     |
[INFO] [stdout] 105 |         let source = dispatch_position;
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 105 |         let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(source) = dispatch_position;
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/indexed.rs:188:5
[INFO] [stdout]     |
[INFO] [stdout] 188 |     slot0: &[L0],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 188 |     <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0): &[L0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/indexed.rs:189:5
[INFO] [stdout]     |
[INFO] [stdout] 189 |     slot1: &[L1],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 189 |     <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1): &[L1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/indexed.rs:190:5
[INFO] [stdout]     |
[INFO] [stdout] 190 |     slot2: &[L2],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 190 |     <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2): &[L2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/indexed.rs:191:5
[INFO] [stdout]     |
[INFO] [stdout] 191 |     slot3: &[L3],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 191 |     <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3): &[L3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/indexed.rs:192:5
[INFO] [stdout]     |
[INFO] [stdout] 192 |     slot4: &[L4],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 |     <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4): &[L4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/indexed.rs:193:5
[INFO] [stdout]     |
[INFO] [stdout] 193 |     slot5: &[L5],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 |     <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5): &[L5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/indexed.rs:194:5
[INFO] [stdout]     |
[INFO] [stdout] 194 |     slot6: &[L6],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 194 |     <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6): &[L6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/indexed.rs:195:5
[INFO] [stdout]     |
[INFO] [stdout] 195 |     slot7: &[L7],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 195 |     <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7): &[L7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/indexed.rs:196:5
[INFO] [stdout]     |
[INFO] [stdout] 196 |     slot8: &[L8],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 196 |     <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8): &[L8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/indexed.rs:197:5
[INFO] [stdout]     |
[INFO] [stdout] 197 |     slot9: &[L9],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9): &[L9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/indexed.rs:198:5
[INFO] [stdout]     |
[INFO] [stdout] 198 |     slot10: &[L10],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10): &[L10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/indexed.rs:199:5
[INFO] [stdout]     |
[INFO] [stdout] 199 |     slot11: &[L11],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 |     <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11): &[L11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/indexed.rs:200:5
[INFO] [stdout]     |
[INFO] [stdout] 200 |     slot12: &[L12],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 200 |     <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12): &[L12],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/indexed.rs:201:5
[INFO] [stdout]     |
[INFO] [stdout] 201 |     read_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(read_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/indexed.rs:227:13
[INFO] [stdout]     |
[INFO] [stdout] 227 |         let source_position = resolved[base] as usize;
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 227 |         let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(source_position) = resolved[base] as usize;
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/indexed.rs:233:13
[INFO] [stdout]     |
[INFO] [stdout] 233 |         let source = SourceExpr::eval13(
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 |         let <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(source) = SourceExpr::eval13(
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]    --> src/core/indexed.rs:203:5
[INFO] [stdout]     |
[INFO] [stdout] 203 |     out0: &mut [O0],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 |     <&mut cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(out0): &mut [O0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]    --> src/core/indexed.rs:204:5
[INFO] [stdout]     |
[INFO] [stdout] 204 |     out1: &mut [O1],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 204 |     <&mut cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(out1): &mut [O1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/indexed.rs:205:5
[INFO] [stdout]     |
[INFO] [stdout] 205 |     out2: &mut [O2],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 |     <&mut cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(out2): &mut [O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/indexed.rs:206:5
[INFO] [stdout]     |
[INFO] [stdout] 206 |     out3: &mut [O3],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 |     <&mut cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(out3): &mut [O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/indexed.rs:207:5
[INFO] [stdout]     |
[INFO] [stdout] 207 |     out4: &mut [O4],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 |     <&mut cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(out4): &mut [O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/indexed.rs:208:5
[INFO] [stdout]     |
[INFO] [stdout] 208 |     out5: &mut [O5],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 208 |     <&mut cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(out5): &mut [O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/indexed.rs:209:5
[INFO] [stdout]     |
[INFO] [stdout] 209 |     out6: &mut [O6],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 |     <&mut cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(out6): &mut [O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/indexed.rs:210:5
[INFO] [stdout]     |
[INFO] [stdout] 210 |     out7: &mut [O7],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 210 |     <&mut cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(out7): &mut [O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/indexed.rs:211:5
[INFO] [stdout]     |
[INFO] [stdout] 211 |     out8: &mut [O8],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 211 |     <&mut cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(out8): &mut [O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/indexed.rs:212:5
[INFO] [stdout]     |
[INFO] [stdout] 212 |     out9: &mut [O9],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 |     <&mut cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(out9): &mut [O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/indexed.rs:213:5
[INFO] [stdout]     |
[INFO] [stdout] 213 |     out10: &mut [O10],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 |     <&mut cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(out10): &mut [O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/indexed.rs:214:5
[INFO] [stdout]     |
[INFO] [stdout] 214 |     out11: &mut [O11],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 |     <&mut cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(out11): &mut [O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/indexed.rs:215:5
[INFO] [stdout]     |
[INFO] [stdout] 215 |     write_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 215 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(write_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/indexed.rs:228:13
[INFO] [stdout]     |
[INFO] [stdout] 228 |         let output_position = if gather {
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 228 |         let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(output_position) = if gather {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/indexed.rs:321:5
[INFO] [stdout]     |
[INFO] [stdout] 321 |     slot0: &[L0],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 321 |     <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0): &[L0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/indexed.rs:322:5
[INFO] [stdout]     |
[INFO] [stdout] 322 |     slot1: &[L1],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 322 |     <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1): &[L1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/indexed.rs:323:5
[INFO] [stdout]     |
[INFO] [stdout] 323 |     slot2: &[L2],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 |     <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2): &[L2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/indexed.rs:324:5
[INFO] [stdout]     |
[INFO] [stdout] 324 |     slot3: &[L3],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 324 |     <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3): &[L3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/indexed.rs:325:5
[INFO] [stdout]     |
[INFO] [stdout] 325 |     slot4: &[L4],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 325 |     <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4): &[L4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/indexed.rs:326:5
[INFO] [stdout]     |
[INFO] [stdout] 326 |     slot5: &[L5],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 326 |     <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5): &[L5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/indexed.rs:327:5
[INFO] [stdout]     |
[INFO] [stdout] 327 |     slot6: &[L6],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 327 |     <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6): &[L6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/indexed.rs:328:5
[INFO] [stdout]     |
[INFO] [stdout] 328 |     slot7: &[L7],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 |     <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7): &[L7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/indexed.rs:329:5
[INFO] [stdout]     |
[INFO] [stdout] 329 |     slot8: &[L8],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 329 |     <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8): &[L8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/indexed.rs:330:5
[INFO] [stdout]     |
[INFO] [stdout] 330 |     slot9: &[L9],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 330 |     <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9): &[L9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/indexed.rs:331:5
[INFO] [stdout]     |
[INFO] [stdout] 331 |     slot10: &[L10],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 331 |     <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10): &[L10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/indexed.rs:332:5
[INFO] [stdout]     |
[INFO] [stdout] 332 |     slot11: &[L11],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 332 |     <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11): &[L11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/indexed.rs:333:5
[INFO] [stdout]     |
[INFO] [stdout] 333 |     slot12: &[L12],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 333 |     <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12): &[L12],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/indexed.rs:348:5
[INFO] [stdout]     |
[INFO] [stdout] 348 |     metadata: &[u32],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(metadata): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/indexed.rs:352:13
[INFO] [stdout]     |
[INFO] [stdout] 352 |         let source_position =
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 352 |         let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(source_position) =
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/indexed.rs:354:13
[INFO] [stdout]     |
[INFO] [stdout] 354 |         let source = SourceExpr::eval13_at(
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |         let <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(source) = SourceExpr::eval13_at(
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]    --> src/core/indexed.rs:336:5
[INFO] [stdout]     |
[INFO] [stdout] 336 |     out0: &mut [O0],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 |     <&mut cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(out0): &mut [O0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]    --> src/core/indexed.rs:337:5
[INFO] [stdout]     |
[INFO] [stdout] 337 |     out1: &mut [O1],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 |     <&mut cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(out1): &mut [O1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/indexed.rs:338:5
[INFO] [stdout]     |
[INFO] [stdout] 338 |     out2: &mut [O2],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 338 |     <&mut cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(out2): &mut [O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/indexed.rs:339:5
[INFO] [stdout]     |
[INFO] [stdout] 339 |     out3: &mut [O3],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 339 |     <&mut cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(out3): &mut [O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/indexed.rs:340:5
[INFO] [stdout]     |
[INFO] [stdout] 340 |     out4: &mut [O4],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 340 |     <&mut cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(out4): &mut [O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/indexed.rs:341:5
[INFO] [stdout]     |
[INFO] [stdout] 341 |     out5: &mut [O5],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 341 |     <&mut cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(out5): &mut [O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/indexed.rs:342:5
[INFO] [stdout]     |
[INFO] [stdout] 342 |     out6: &mut [O6],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 |     <&mut cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(out6): &mut [O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/indexed.rs:343:5
[INFO] [stdout]     |
[INFO] [stdout] 343 |     out7: &mut [O7],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 |     <&mut cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(out7): &mut [O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/indexed.rs:344:5
[INFO] [stdout]     |
[INFO] [stdout] 344 |     out8: &mut [O8],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 344 |     <&mut cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(out8): &mut [O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/indexed.rs:345:5
[INFO] [stdout]     |
[INFO] [stdout] 345 |     out9: &mut [O9],
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 345 |     <&mut cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(out9): &mut [O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/indexed.rs:346:5
[INFO] [stdout]     |
[INFO] [stdout] 346 |     out10: &mut [O10],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 346 |     <&mut cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(out10): &mut [O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/indexed.rs:347:5
[INFO] [stdout]     |
[INFO] [stdout] 347 |     out11: &mut [O11],
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 347 |     <&mut cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(out11): &mut [O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/indexed.rs:350:9
[INFO] [stdout]     |
[INFO] [stdout] 350 |     let output_position = ABSOLUTE_POS as usize;
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 350 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(output_position) = ABSOLUTE_POS as usize;
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL0]>`
[INFO] [stdout]    --> src/core/merge.rs:233:64
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right...
[INFO] [stdout]     |                                                                ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:<&cubecl::frontend::NativeExpand<[RL0]> as Into<_>>::into(right0),LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL1]>`
[INFO] [stdout]    --> src/core/merge.rs:233:85
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right...
[INFO] [stdout]     |                                                                                     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:<&cubecl::frontend::NativeExpand<[RL1]> as Into<_>>::into(right1),LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL2]>`
[INFO] [stdout]    --> src/core/merge.rs:233:106
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right...
[INFO] [stdout]     |                                                                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:<&cubecl::frontend::NativeExpand<[RL2]> as Into<_>>::into(right2),LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL3]>`
[INFO] [stdout]    --> src/core/merge.rs:233:127
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ght0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:righ...
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:<&cubecl::frontend::NativeExpand<[RL3]> as Into<_>>::into(right3),LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL4]>`
[INFO] [stdout]    --> src/core/merge.rs:233:148
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ght1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:righ...
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:<&cubecl::frontend::NativeExpand<[RL4]> as Into<_>>::into(right4),LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL5]>`
[INFO] [stdout]    --> src/core/merge.rs:233:169
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ght2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:righ...
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:<&cubecl::frontend::NativeExpand<[RL5]> as Into<_>>::into(right5),LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL6]>`
[INFO] [stdout]    --> src/core/merge.rs:233:190
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ght3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:righ...
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:<&cubecl::frontend::NativeExpand<[RL6]> as Into<_>>::into(right6),LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL7]>`
[INFO] [stdout]    --> src/core/merge.rs:233:211
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ght4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:r...
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:<&cubecl::frontend::NativeExpand<[RL7]> as Into<_>>::into(right7),LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL8]>`
[INFO] [stdout]    --> src/core/merge.rs:233:232
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ght5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL...
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:<&cubecl::frontend::NativeExpand<[RL8]> as Into<_>>::into(right8),LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL9]>`
[INFO] [stdout]    --> src/core/merge.rs:233:253
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ght6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left1...
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:<&cubecl::frontend::NativeExpand<[RL9]> as Into<_>>::into(right9),LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                                                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL10]>`
[INFO] [stdout]    --> src/core/merge.rs:233:277
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:<&cubecl::frontend::NativeExpand<[RL10]> as Into<_>>::into(right10),LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL11]>`
[INFO] [stdout]    --> src/core/merge.rs:233:302
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:<&cubecl::frontend::NativeExpand<[RL11]> as Into<_>>::into(right11),LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                                                                                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[RL12]>`
[INFO] [stdout]    --> src/core/merge.rs:233:327
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ft10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:<&cubecl::frontend::NativeExpand<[RL12]> as Into<_>>::into(right12)]);
[INFO] [stdout]     |                                                                                                                                                                                                                                                                                                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL0]>`
[INFO] [stdout]    --> src/core/merge.rs:233:54
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right...
[INFO] [stdout]     |                                                      ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:<&cubecl::frontend::NativeExpand<[LL0]> as Into<_>>::into(left0):RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL1]>`
[INFO] [stdout]    --> src/core/merge.rs:233:75
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right...
[INFO] [stdout]     |                                                                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:<&cubecl::frontend::NativeExpand<[LL1]> as Into<_>>::into(left1):RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL2]>`
[INFO] [stdout]    --> src/core/merge.rs:233:96
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right...
[INFO] [stdout]     |                                                                                                ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:<&cubecl::frontend::NativeExpand<[LL2]> as Into<_>>::into(left2):RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL3]>`
[INFO] [stdout]    --> src/core/merge.rs:233:117
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right...
[INFO] [stdout]     |                                                                                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:<&cubecl::frontend::NativeExpand<[LL3]> as Into<_>>::into(left3):RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL4]>`
[INFO] [stdout]    --> src/core/merge.rs:233:138
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ft1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left...
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:<&cubecl::frontend::NativeExpand<[LL4]> as Into<_>>::into(left4):RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL5]>`
[INFO] [stdout]    --> src/core/merge.rs:233:159
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ft2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left...
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:<&cubecl::frontend::NativeExpand<[LL5]> as Into<_>>::into(left5):RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL6]>`
[INFO] [stdout]    --> src/core/merge.rs:233:180
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ft3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left...
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:<&cubecl::frontend::NativeExpand<[LL6]> as Into<_>>::into(left6):RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL7]>`
[INFO] [stdout]    --> src/core/merge.rs:233:201
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ft4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:lef...
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:<&cubecl::frontend::NativeExpand<[LL7]> as Into<_>>::into(left7):RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL8]>`
[INFO] [stdout]    --> src/core/merge.rs:233:222
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ft5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11...
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:<&cubecl::frontend::NativeExpand<[LL8]> as Into<_>>::into(left8):RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL9]>`
[INFO] [stdout]    --> src/core/merge.rs:233:243
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ft6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,...
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:<&cubecl::frontend::NativeExpand<[LL9]> as Into<_>>::into(left9):RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL10]>`
[INFO] [stdout]    --> src/core/merge.rs:233:265
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...t7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right...
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:<&cubecl::frontend::NativeExpand<[LL10]> as Into<_>>::into(left10):RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                                                                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL11]>`
[INFO] [stdout]    --> src/core/merge.rs:233:290
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...L8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:<&cubecl::frontend::NativeExpand<[LL11]> as Into<_>>::into(left11):RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                                                                                                  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[LL12]>`
[INFO] [stdout]    --> src/core/merge.rs:233:315
[INFO] [stdout]     |
[INFO] [stdout] 233 | ...ight9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:left12:RL12:right12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 | define_merge_control_kernel!(merge_control_a13; [LL0:left0:RL0:right0,LL1:left1:RL1:right1,LL2:left2:RL2:right2,LL3:left3:RL3:right3,LL4:left4:RL4:right4,LL5:left5:RL5:right5,LL6:left6:RL6:right6,LL7:left7:RL7:right7,LL8:left8:RL8:right8,LL9:left9:RL9:right9,LL10:left10:RL10:right10,LL11:left11:RL11:right11,LL12:<&cubecl::frontend::NativeExpand<[LL12]> as Into<_>>::into(left12):RL12:right12]);
[INFO] [stdout]     |                                                                                                                                                                                                                                                                                                                           +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:29:42
[INFO] [stdout]    |
[INFO] [stdout] 29 | pub(crate) fn binary_predicate<Item, Op>(lhs: Item, rhs: Item) -> bool
[INFO] [stdout]    |                                          ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 29 | pub(crate) fn binary_predicate<Item, Op>(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(lhs): Item, rhs: Item) -> bool
[INFO] [stdout]    |                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:29:53
[INFO] [stdout]    |
[INFO] [stdout] 29 | pub(crate) fn binary_predicate<Item, Op>(lhs: Item, rhs: Item) -> bool
[INFO] [stdout]    |                                                     ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 29 | pub(crate) fn binary_predicate<Item, Op>(lhs: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(rhs): Item) -> bool
[INFO] [stdout]    |                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/ordering.rs:34:25
[INFO] [stdout]    |
[INFO] [stdout] 34 |     crate::flag::is_set(Op::apply(lhs, rhs))
[INFO] [stdout]    |                         ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 34 |     crate::flag::is_set(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(Op::apply(lhs, rhs)))
[INFO] [stdout]    |                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:53:28
[INFO] [stdout]    |
[INFO] [stdout] 53 |     fn rhs_wins(lhs: Item, rhs: Item) -> bool {
[INFO] [stdout]    |                            ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 |     fn rhs_wins(lhs: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(rhs): Item) -> bool {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:53:17
[INFO] [stdout]    |
[INFO] [stdout] 53 |     fn rhs_wins(lhs: Item, rhs: Item) -> bool {
[INFO] [stdout]    |                 ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 |     fn rhs_wins(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(lhs): Item, rhs: Item) -> bool {
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:64:17
[INFO] [stdout]    |
[INFO] [stdout] 64 |     fn rhs_wins(lhs: Item, rhs: Item) -> bool {
[INFO] [stdout]    |                 ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 64 |     fn rhs_wins(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(lhs): Item, rhs: Item) -> bool {
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:64:28
[INFO] [stdout]    |
[INFO] [stdout] 64 |     fn rhs_wins(lhs: Item, rhs: Item) -> bool {
[INFO] [stdout]    |                            ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 64 |     fn rhs_wins(lhs: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(rhs): Item) -> bool {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:75:17
[INFO] [stdout]    |
[INFO] [stdout] 75 |     fn rhs_wins(lhs: Item, rhs: Item) -> bool {
[INFO] [stdout]    |                 ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 |     fn rhs_wins(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(lhs): Item, rhs: Item) -> bool {
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:75:28
[INFO] [stdout]    |
[INFO] [stdout] 75 |     fn rhs_wins(lhs: Item, rhs: Item) -> bool {
[INFO] [stdout]    |                            ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 |     fn rhs_wins(lhs: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(rhs): Item) -> bool {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/ordering.rs:84:14
[INFO] [stdout]    |
[INFO] [stdout] 84 |     fn apply(lhs: u32, rhs: u32) -> u32 {
[INFO] [stdout]    |              ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(lhs): u32, rhs: u32) -> u32 {
[INFO] [stdout]    |              +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/ordering.rs:84:24
[INFO] [stdout]    |
[INFO] [stdout] 84 |     fn apply(lhs: u32, rhs: u32) -> u32 {
[INFO] [stdout]    |                        ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |     fn apply(lhs: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(rhs): u32) -> u32 {
[INFO] [stdout]    |                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:99:14
[INFO] [stdout]    |
[INFO] [stdout] 99 |     fn apply(previous: Item, current: Item, index: u32) -> u32 {
[INFO] [stdout]    |              ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 |     fn apply(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(previous): Item, current: Item, index: u32) -> u32 {
[INFO] [stdout]    |              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/ordering.rs:99:30
[INFO] [stdout]    |
[INFO] [stdout] 99 |     fn apply(previous: Item, current: Item, index: u32) -> u32 {
[INFO] [stdout]    |                              ^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 99 |     fn apply(previous: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(current): Item, index: u32) -> u32 {
[INFO] [stdout]    |                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/ordering.rs:120:30
[INFO] [stdout]     |
[INFO] [stdout] 120 |     fn apply(previous: Item, current: Item, index: u32) -> u32 {
[INFO] [stdout]     |                              ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 |     fn apply(previous: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(current): Item, index: u32) -> u32 {
[INFO] [stdout]     |                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/ordering.rs:120:14
[INFO] [stdout]     |
[INFO] [stdout] 120 |     fn apply(previous: Item, current: Item, index: u32) -> u32 {
[INFO] [stdout]     |              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 |     fn apply(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(previous): Item, current: Item, index: u32) -> u32 {
[INFO] [stdout]     |              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/ordering.rs:142:14
[INFO] [stdout]     |
[INFO] [stdout] 142 |     fn apply(previous: Item, current: Item) -> u32 {
[INFO] [stdout]     |              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |     fn apply(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(previous): Item, current: Item) -> u32 {
[INFO] [stdout]     |              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/ordering.rs:142:30
[INFO] [stdout]     |
[INFO] [stdout] 142 |     fn apply(previous: Item, current: Item) -> u32 {
[INFO] [stdout]     |                              ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |     fn apply(previous: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(current): Item) -> u32 {
[INFO] [stdout]     |                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/ordering.rs:163:30
[INFO] [stdout]     |
[INFO] [stdout] 163 |     fn apply(previous: Item, current: Item) -> u32 {
[INFO] [stdout]     |                              ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 |     fn apply(previous: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(current): Item) -> u32 {
[INFO] [stdout]     |                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/ordering.rs:163:14
[INFO] [stdout]     |
[INFO] [stdout] 163 |     fn apply(previous: Item, current: Item) -> u32 {
[INFO] [stdout]     |              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 |     fn apply(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(previous): Item, current: Item) -> u32 {
[INFO] [stdout]     |              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:68
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:s...
[INFO] [stdout]     |                                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0),L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:77
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:s...
[INFO] [stdout]     |                                                                             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1),L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:86
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:s...
[INFO] [stdout]     |                                                                                      ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2),L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:95
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:s...
[INFO] [stdout]     |                                                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3),L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:104
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:s...
[INFO] [stdout]     |                                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4),L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:113
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:s...
[INFO] [stdout]     |                                                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5),L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:122
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:s...
[INFO] [stdout]     |                                                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6),L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:131
[INFO] [stdout]     |
[INFO] [stdout] 213 | ...ot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7),L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:140
[INFO] [stdout]     |
[INFO] [stdout] 213 | ...ot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8),L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:149
[INFO] [stdout]     |
[INFO] [stdout] 213 | ...ot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9),L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:159
[INFO] [stdout]     |
[INFO] [stdout] 213 | ...t3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10),L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:170
[INFO] [stdout]     |
[INFO] [stdout] 213 | ...,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11),L12:slot12);
[INFO] [stdout]     |                                                                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/ordering.rs:213:181
[INFO] [stdout]     |
[INFO] [stdout] 213 | ...6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 213 | define_adjacent_flags_kernel!(adjacent_flags_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12));
[INFO] [stdout]     |                                                                                                                                                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:84
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slo...
[INFO] [stdout]     |                                                                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0),L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:93
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slo...
[INFO] [stdout]     |                                                                                             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1),L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:102
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slo...
[INFO] [stdout]     |                                                                                                      ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2),L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:111
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slo...
[INFO] [stdout]     |                                                                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3),L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:120
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slo...
[INFO] [stdout]     |                                                                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4),L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:129
[INFO] [stdout]     |
[INFO] [stdout] 445 | ...al13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12...
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5),L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:138
[INFO] [stdout]     |
[INFO] [stdout] 445 | ...13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6),L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:147
[INFO] [stdout]     |
[INFO] [stdout] 445 | ...ot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7),L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:156
[INFO] [stdout]     |
[INFO] [stdout] 445 | ...ot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8),L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:165
[INFO] [stdout]     |
[INFO] [stdout] 445 | ...ot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9),L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:175
[INFO] [stdout]     |
[INFO] [stdout] 445 | ...t3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10),L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:186
[INFO] [stdout]     |
[INFO] [stdout] 445 | ...,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11),L12:slot12);
[INFO] [stdout]     |                                                                                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/ordering.rs:445:197
[INFO] [stdout]     |
[INFO] [stdout] 445 | ...6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 | define_block_sort_permutation_kernel!(block_sort_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12));
[INFO] [stdout]     |                                                                                                                                                                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:74
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot...
[INFO] [stdout]     |                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0),L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:83
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot...
[INFO] [stdout]     |                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1),L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:92
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot...
[INFO] [stdout]     |                                                                                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2),L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:101
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot...
[INFO] [stdout]     |                                                                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3),L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:110
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot...
[INFO] [stdout]     |                                                                                                              ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4),L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:119
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot...
[INFO] [stdout]     |                                                                                                                       ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5),L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:128
[INFO] [stdout]     |
[INFO] [stdout] 719 | ...13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6),L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:137
[INFO] [stdout]     |
[INFO] [stdout] 719 | ...ot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7),L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:146
[INFO] [stdout]     |
[INFO] [stdout] 719 | ...ot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8),L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:155
[INFO] [stdout]     |
[INFO] [stdout] 719 | ...ot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9),L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                           +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:165
[INFO] [stdout]     |
[INFO] [stdout] 719 | ...t3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10),L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                                                                                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:176
[INFO] [stdout]     |
[INFO] [stdout] 719 | ...,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11),L12:slot12);
[INFO] [stdout]     |                                                                                                                                                                                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/ordering.rs:719:187
[INFO] [stdout]     |
[INFO] [stdout] 719 | ...6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 | define_merge_permutation_kernel!(merge_permutation_a13,Eval13,eval13; L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12));
[INFO] [stdout]     |                                                                                                                                                                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Input as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/predicate.rs:17:38
[INFO] [stdout]    |
[INFO] [stdout] 17 | pub(crate) fn predicate<Input, Pred>(input: Input) -> bool
[INFO] [stdout]    |                                      ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 17 | pub(crate) fn predicate<Input, Pred>(<<Input as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(input): Input) -> bool
[INFO] [stdout]    |                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/predicate.rs:22:25
[INFO] [stdout]    |
[INFO] [stdout] 22 |     crate::flag::is_set(Pred::apply(input))
[INFO] [stdout]    |                         ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 22 |     crate::flag::is_set(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(Pred::apply(input)))
[INFO] [stdout]    |                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Input as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/predicate.rs:36:14
[INFO] [stdout]    |
[INFO] [stdout] 36 |     fn apply(input: Input) -> MFlag {
[INFO] [stdout]    |              ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 |     fn apply(<<Input as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(input): Input) -> MFlag {
[INFO] [stdout]    |              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/predicate.rs:37:52
[INFO] [stdout]    |
[INFO] [stdout] 37 |         crate::flag::from_bool(crate::flag::is_set(Pred::apply(input)))
[INFO] [stdout]    |                                                    ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 37 |         crate::flag::from_bool(crate::flag::is_set(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(Pred::apply(input))))
[INFO] [stdout]    |                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<bool>`
[INFO] [stdout]   --> src/core/predicate.rs:37:32
[INFO] [stdout]    |
[INFO] [stdout] 37 |         crate::flag::from_bool(crate::flag::is_set(Pred::apply(input)))
[INFO] [stdout]    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 37 |         crate::flag::from_bool(<cubecl::frontend::NativeExpand<bool> as Into<_>>::into(crate::flag::is_set(Pred::apply(input))))
[INFO] [stdout]    |                                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/predicate.rs:54:14
[INFO] [stdout]    |
[INFO] [stdout] 54 |     fn apply(lhs: u32, rhs: u32) -> u32 {
[INFO] [stdout]    |              ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |     fn apply(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(lhs): u32, rhs: u32) -> u32 {
[INFO] [stdout]    |              +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/predicate.rs:54:24
[INFO] [stdout]    |
[INFO] [stdout] 54 |     fn apply(lhs: u32, rhs: u32) -> u32 {
[INFO] [stdout]    |                        ^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |     fn apply(lhs: u32, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(rhs): u32) -> u32 {
[INFO] [stdout]    |                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Input as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/predicate.rs:69:14
[INFO] [stdout]    |
[INFO] [stdout] 69 |     fn apply(input: Input, index: u32) -> u32 {
[INFO] [stdout]    |              ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 |     fn apply(<<Input as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(input): Input, index: u32) -> u32 {
[INFO] [stdout]    |              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Input as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/predicate.rs:88:14
[INFO] [stdout]    |
[INFO] [stdout] 88 |     fn apply(previous: Input, current: Input, index: u32) -> u32 {
[INFO] [stdout]    |              ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |     fn apply(<<Input as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(previous): Input, current: Input, index: u32) -> u32 {
[INFO] [stdout]    |              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Input as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/predicate.rs:88:31
[INFO] [stdout]    |
[INFO] [stdout] 88 |     fn apply(previous: Input, current: Input, index: u32) -> u32 {
[INFO] [stdout]    |                               ^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |     fn apply(previous: Input, <<Input as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(current): Input, index: u32) -> u32 {
[INFO] [stdout]    |                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/core/radix.rs:67:14
[INFO] [stdout]    |
[INFO] [stdout] 67 |     fn apply(value: f32, shift: u32) -> u32 {
[INFO] [stdout]    |              ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |     fn apply(<cubecl::frontend::NativeExpand<f32> as Into<_>>::into(value): f32, shift: u32) -> u32 {
[INFO] [stdout]    |              +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<f64>`
[INFO] [stdout]   --> src/core/radix.rs:82:14
[INFO] [stdout]    |
[INFO] [stdout] 82 |     fn apply(value: f64, shift: u32) -> u32 {
[INFO] [stdout]    |              ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 |     fn apply(<cubecl::frontend::NativeExpand<f64> as Into<_>>::into(value): f64, shift: u32) -> u32 {
[INFO] [stdout]    |              +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/core/radix.rs:156:53
[INFO] [stdout]     |
[INFO] [stdout] 156 |     let counts = Shared::<[Atomic<u32>]>::new_slice(RADIX_BUCKETS);
[INFO] [stdout]     |                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 156 |     let counts = Shared::<[Atomic<u32>]>::new_slice(<usize as Into<_>>::into(RADIX_BUCKETS));
[INFO] [stdout]     |                                                     +++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/radix.rs:165:13
[INFO] [stdout]     |
[INFO] [stdout] 165 |         let digit = if valid {
[INFO] [stdout]     |             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |         let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(digit) = if valid {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<bool>`
[INFO] [stdout]    --> src/core/radix.rs:164:13
[INFO] [stdout]     |
[INFO] [stdout] 164 |         let valid = index < logical_len[0] as usize;
[INFO] [stdout]     |             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |         let <cubecl::frontend::NativeExpand<bool> as Into<_>>::into(valid) = index < logical_len[0] as usize;
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/radix.rs:170:20
[INFO] [stdout]     |
[INFO] [stdout] 170 |         let (rank, count, _) = crate::core::collective::plane_digit_rank(digit, valid);
[INFO] [stdout]     |                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 170 |         let (rank, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(count), _) = crate::core::collective::plane_digit_rank(digit, valid);
[INFO] [stdout]     |                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/radix.rs:181:5
[INFO] [stdout]     |
[INFO] [stdout] 181 |     histograms: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 181 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(histograms): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/radix.rs:183:5
[INFO] [stdout]     |
[INFO] [stdout] 183 |     block_prefixes: &mut [u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 183 |     <&mut cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(block_prefixes): &mut [u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/radix.rs:184:5
[INFO] [stdout]     |
[INFO] [stdout] 184 |     bucket_totals: &mut [u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 |     <&mut cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(bucket_totals): &mut [u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/radix.rs:209:9
[INFO] [stdout]     |
[INFO] [stdout] 209 |     let value = if block < blocks {
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 |     let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(value) = if block < blocks {
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/radix.rs:227:5
[INFO] [stdout]     |
[INFO] [stdout] 227 |     chunk_totals: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 227 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(chunk_totals): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/radix.rs:232:9
[INFO] [stdout]     |
[INFO] [stdout] 232 |     let chunks = (params[1] as usize).div_ceil(BLOCK_SIZE as usize);
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 232 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(chunks) = (params[1] as usize).div_ceil(BLOCK_SIZE as usize);
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/radix.rs:229:5
[INFO] [stdout]     |
[INFO] [stdout] 229 |     chunk_prefixes: &mut [u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 229 |     <&mut cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(chunk_prefixes): &mut [u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/radix.rs:230:5
[INFO] [stdout]     |
[INFO] [stdout] 230 |     bucket_totals: &mut [u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 |     <&mut cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(bucket_totals): &mut [u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/core/radix.rs:280:53
[INFO] [stdout]     |
[INFO] [stdout] 280 |     let counts = Shared::<[Atomic<u32>]>::new_slice(RADIX_BUCKETS);
[INFO] [stdout]     |                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 280 |     let counts = Shared::<[Atomic<u32>]>::new_slice(<usize as Into<_>>::into(RADIX_BUCKETS));
[INFO] [stdout]     |                                                     +++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/core/radix.rs:273:17
[INFO] [stdout]     |
[INFO] [stdout] 273 |     #[comptime] items_per_unit: usize,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 273 |     #[comptime] <usize as Into<_>>::into(items_per_unit): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/radix.rs:297:13
[INFO] [stdout]     |
[INFO] [stdout] 297 |         let digit = if valid {
[INFO] [stdout]     |             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 |         let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(digit) = if valid {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<bool>`
[INFO] [stdout]    --> src/core/radix.rs:296:13
[INFO] [stdout]     |
[INFO] [stdout] 296 |         let valid = index < logical_len[0] as usize;
[INFO] [stdout]     |             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 296 |         let <cubecl::frontend::NativeExpand<bool> as Into<_>>::into(valid) = index < logical_len[0] as usize;
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/radix.rs:324:34
[INFO] [stdout]     |
[INFO] [stdout] 324 |                     prefix.store(counts[digits[item] as usize].fetch_add(matches[item]));
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 324 |                     prefix.store(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(counts[digits[item] as usize].fetch_add(matches[item])));
[INFO] [stdout]     |                                  +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/radix.rs:326:46
[INFO] [stdout]     |
[INFO] [stdout] 326 |                 ranks[item] += plane_shuffle(prefix.read(), leaders[item]);
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 326 |                 ranks[item] += plane_shuffle(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(prefix.read()), leaders[item]);
[INFO] [stdout]     |                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/radix.rs:333:54
[INFO] [stdout]     |
[INFO] [stdout] 333 |         crate::core::collective::block_exclusive_sum(counts[UNIT_POS as usize].load());
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 333 |         crate::core::collective::block_exclusive_sum(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(counts[UNIT_POS as usize].load()));
[INFO] [stdout]     |                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/core/radix.rs:334:49
[INFO] [stdout]     |
[INFO] [stdout] 334 |     let mut starts = Shared::<[u32]>::new_slice(RADIX_BUCKETS);
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 334 |     let mut starts = Shared::<[u32]>::new_slice(<usize as Into<_>>::into(RADIX_BUCKETS));
[INFO] [stdout]     |                                                 +++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<T>`
[INFO] [stdout]    --> src/core/radix.rs:359:17
[INFO] [stdout]     |
[INFO] [stdout] 359 |             let key = sorted_keys[local];
[INFO] [stdout]     |                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 359 |             let <cubecl::frontend::NativeExpand<T> as Into<_>>::into(key) = sorted_keys[local];
[INFO] [stdout]     |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&<<Leaves as storage::MutableLeaves>::Cells as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:35:50
[INFO] [stdout]    |
[INFO] [stdout] 35 | fn accumulate_register<Item, Leaves, Layout, Op>(cells: &Leaves::Cells, value: Item)
[INFO] [stdout]    |                                                  ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 | fn accumulate_register<Item, Leaves, Layout, Op>(<&<<Leaves as storage::MutableLeaves>::Cells as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(cells): &Leaves::Cells, value: Item)
[INFO] [stdout]    |                                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:42:51
[INFO] [stdout]    |
[INFO] [stdout] 42 |     let accumulated = Op::apply(Layout::recompose(Leaves::read(cells)), value);
[INFO] [stdout]    |                                                   ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 |     let accumulated = Op::apply(Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(cells))), value);
[INFO] [stdout]    |                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:42:33
[INFO] [stdout]    |
[INFO] [stdout] 42 |     let accumulated = Op::apply(Layout::recompose(Leaves::read(cells)), value);
[INFO] [stdout]    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 |     let accumulated = Op::apply(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(cells))), value);
[INFO] [stdout]    |                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:35:73
[INFO] [stdout]    |
[INFO] [stdout] 35 | fn accumulate_register<Item, Leaves, Layout, Op>(cells: &Leaves::Cells, value: Item)
[INFO] [stdout]    |                                                                         ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 | fn accumulate_register<Item, Leaves, Layout, Op>(cells: &Leaves::Cells, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(value): Item)
[INFO] [stdout]    |                                                                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:42:9
[INFO] [stdout]    |
[INFO] [stdout] 42 |     let accumulated = Op::apply(Layout::recompose(Leaves::read(cells)), value);
[INFO] [stdout]    |         ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 |     let <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(accumulated) = Op::apply(Layout::recompose(Leaves::read(cells)), value);
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:43:26
[INFO] [stdout]    |
[INFO] [stdout] 43 |     Leaves::store(cells, Layout::decompose(accumulated));
[INFO] [stdout]    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 |     Leaves::store(cells, <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(accumulated)));
[INFO] [stdout]    |                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:47:48
[INFO] [stdout]    |
[INFO] [stdout] 47 | fn reduce_plane_full<Item, Leaves, Layout, Op>(value: Item) -> Leaves
[INFO] [stdout]    |                                                ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 47 | fn reduce_plane_full<Item, Leaves, Layout, Op>(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(value): Item) -> Leaves
[INFO] [stdout]    |                                                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:57:49
[INFO] [stdout]    |
[INFO] [stdout] 57 |         let right = Leaves::shuffle_leaves_down(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |                                                 ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 |         let right = Leaves::shuffle_leaves_down(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&cells)), offset.read());
[INFO] [stdout]    |                                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/reduce.rs:57:71
[INFO] [stdout]    |
[INFO] [stdout] 57 |         let right = Leaves::shuffle_leaves_down(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |                                                                       ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 |         let right = Leaves::shuffle_leaves_down(Leaves::read(&cells), <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(offset.read()));
[INFO] [stdout]    |                                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:60:35
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout]    |                                   ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&cells))),
[INFO] [stdout]    |                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:60:17
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&cells))),
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:57:13
[INFO] [stdout]    |
[INFO] [stdout] 57 |         let right = Leaves::shuffle_leaves_down(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |             ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 |         let <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(right) = Leaves::shuffle_leaves_down(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |                 Layout::recompose(right),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 |                 <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(right)),
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:59:17
[INFO] [stdout]    |
[INFO] [stdout] 59 |             let combined = Op::apply(
[INFO] [stdout]    |                 ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |             let <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(combined) = Op::apply(
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:63:35
[INFO] [stdout]    |
[INFO] [stdout] 63 |             Leaves::store(&cells, Layout::decompose(combined));
[INFO] [stdout]    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 |             Leaves::store(&cells, <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(combined)));
[INFO] [stdout]    |                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:71:49
[INFO] [stdout]    |
[INFO] [stdout] 71 | fn reduce_plane_valid<Item, Leaves, Layout, Op>(value: Item, valid: u32) -> (Leaves, u32)
[INFO] [stdout]    |                                                 ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 | fn reduce_plane_valid<Item, Leaves, Layout, Op>(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(value): Item, valid: u32) -> (Leaves, u32)
[INFO] [stdout]    |                                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/reduce.rs:71:62
[INFO] [stdout]    |
[INFO] [stdout] 71 | fn reduce_plane_valid<Item, Leaves, Layout, Op>(value: Item, valid: u32) -> (Leaves, u32)
[INFO] [stdout]    |                                                              ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 | fn reduce_plane_valid<Item, Leaves, Layout, Op>(value: Item, <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(valid): u32) -> (Leaves, u32)
[INFO] [stdout]    |                                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:82:49
[INFO] [stdout]    |
[INFO] [stdout] 82 |         let right = Leaves::shuffle_leaves_down(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |                                                 ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 |         let right = Leaves::shuffle_leaves_down(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&cells)), offset.read());
[INFO] [stdout]    |                                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/reduce.rs:82:71
[INFO] [stdout]    |
[INFO] [stdout] 82 |         let right = Leaves::shuffle_leaves_down(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |                                                                       ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 |         let right = Leaves::shuffle_leaves_down(Leaves::read(&cells), <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(offset.read()));
[INFO] [stdout]    |                                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/reduce.rs:84:46
[INFO] [stdout]    |
[INFO] [stdout] 84 |         let right_valid = plane_shuffle_down(cell_valid.read(), offset.read());
[INFO] [stdout]    |                                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |         let right_valid = plane_shuffle_down(<cubecl::frontend::NativeExpand<u32> as Into<_>>::into(cell_valid.read()), offset.read());
[INFO] [stdout]    |                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/reduce.rs:84:65
[INFO] [stdout]    |
[INFO] [stdout] 84 |         let right_valid = plane_shuffle_down(cell_valid.read(), offset.read());
[INFO] [stdout]    |                                                                 ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |         let right_valid = plane_shuffle_down(cell_valid.read(), <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(offset.read()));
[INFO] [stdout]    |                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:88:39
[INFO] [stdout]    |
[INFO] [stdout] 88 |                     Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |                     Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&cells))),
[INFO] [stdout]    |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:88:21
[INFO] [stdout]    |
[INFO] [stdout] 88 |                     Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout]    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&cells))),
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:89:39
[INFO] [stdout]    |
[INFO] [stdout] 89 |                     Layout::recompose(Leaves::read(&right_cells)),
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 |                     Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&right_cells))),
[INFO] [stdout]    |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:89:21
[INFO] [stdout]    |
[INFO] [stdout] 89 |                     Layout::recompose(Leaves::read(&right_cells)),
[INFO] [stdout]    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 89 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&right_cells))),
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:87:21
[INFO] [stdout]    |
[INFO] [stdout] 87 |                 let combined = Op::apply(
[INFO] [stdout]    |                     ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 |                 let <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(combined) = Op::apply(
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:91:39
[INFO] [stdout]    |
[INFO] [stdout] 91 |                 Leaves::store(&cells, Layout::decompose(combined));
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 |                 Leaves::store(&cells, <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(combined)));
[INFO] [stdout]    |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/reduce.rs:93:39
[INFO] [stdout]    |
[INFO] [stdout] 93 |                 Leaves::store(&cells, Leaves::read(&right_cells));
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |                 Leaves::store(&cells, <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&right_cells)));
[INFO] [stdout]    |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/core/reduce.rs:106:17
[INFO] [stdout]     |
[INFO] [stdout] 106 |     #[comptime] plane_capacity: usize,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 |     #[comptime] <usize as Into<_>>::into(plane_capacity): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/reduce.rs:125:13
[INFO] [stdout]     |
[INFO] [stdout] 125 |         let source = if UNIT_POS_PLANE < plane_count {
[INFO] [stdout]     |             ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 125 |         let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(source) = if UNIT_POS_PLANE < plane_count {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:136:49
[INFO] [stdout]     |
[INFO] [stdout] 136 |             Layout::decompose(Layout::recompose(Leaves::load_shared(&shared, source))).into_cells();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 |             Layout::decompose(Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::load_shared(&shared, source)))).into_cells();
[INFO] [stdout]     |                                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:136:31
[INFO] [stdout]     |
[INFO] [stdout] 136 |             Layout::decompose(Layout::recompose(Leaves::load_shared(&shared, source))).into_cells();
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 |             Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::load_shared(&shared, source)))).into_cells();
[INFO] [stdout]     |                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/reduce.rs:130:13
[INFO] [stdout]     |
[INFO] [stdout] 130 |         let source_valid = if UNIT_POS_PLANE < plane_count {
[INFO] [stdout]     |             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 |         let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(source_valid) = if UNIT_POS_PLANE < plane_count {
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/reduce.rs:140:17
[INFO] [stdout]     |
[INFO] [stdout] 140 |             let index = cursor.read() as usize;
[INFO] [stdout]     |                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 140 |             let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index) = cursor.read() as usize;
[INFO] [stdout]     |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:146:43
[INFO] [stdout]     |
[INFO] [stdout] 146 |                         Layout::recompose(Leaves::read(&next)),
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 146 |                         Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&next))),
[INFO] [stdout]     |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:146:25
[INFO] [stdout]     |
[INFO] [stdout] 146 |                         Layout::recompose(Leaves::read(&next)),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 146 |                         <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&next))),
[INFO] [stdout]     |                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:149:49
[INFO] [stdout]     |
[INFO] [stdout] 149 |                     Leaves::store(&accumulator, Leaves::read(&next));
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |                     Leaves::store(&accumulator, <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&next)));
[INFO] [stdout]     |                                                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:156:31
[INFO] [stdout]     |
[INFO] [stdout] 156 |             Layout::recompose(Leaves::read(&accumulator)),
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 156 |             Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&accumulator))),
[INFO] [stdout]     |                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:156:13
[INFO] [stdout]     |
[INFO] [stdout] 156 |             Layout::recompose(Leaves::read(&accumulator)),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 156 |             <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&accumulator))),
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/reduce.rs:157:13
[INFO] [stdout]     |
[INFO] [stdout] 157 |             accumulator_valid.read(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 |             <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(accumulator_valid.read()),
[INFO] [stdout]     |             +++++++++++++++++++++++++++++++++++++++++++++++++++++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:155:13
[INFO] [stdout]     |
[INFO] [stdout] 155 |           let block_result = reduce_plane_valid::<Item, Leaves, Layout, Op>(
[INFO] [stdout]     |  _____________^
[INFO] [stdout] 156 | |             Layout::recompose(Leaves::read(&accumulator)),
[INFO] [stdout] 157 | |             accumulator_valid.read(),
[INFO] [stdout] 158 | |         );
[INFO] [stdout] 159 | |         if UNIT_POS_PLANE == 0u32 && block_result.1 != 0u32 {
[INFO] [stdout] 160 | |             Leaves::store(&result, block_result.0);
[INFO] [stdout]     | |_________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 155 ~         let <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(block_result = reduce_plane_valid::<Item, Leaves, Layout, Op>(
[INFO] [stdout] 156 |             Layout::recompose(Leaves::read(&accumulator)),
[INFO] [stdout] ...
[INFO] [stdout] 159 |         if UNIT_POS_PLANE == 0u32 && block_result.1 != 0u32 {
[INFO] [stdout] 160 ~             Leaves::store(&result, block_result.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:187:5
[INFO] [stdout]     |
[INFO] [stdout] 187 |     value: Leaves,
[INFO] [stdout]     |     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 |     <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(value): Leaves,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/core/reduce.rs:188:5
[INFO] [stdout]     |
[INFO] [stdout] 188 |     value_valid: u32,
[INFO] [stdout]     |     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 188 |     <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(value_valid): u32,
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/core/reduce.rs:203:17
[INFO] [stdout]     |
[INFO] [stdout] 203 |     #[comptime] plane_capacity: usize,
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 |     #[comptime] <usize as Into<_>>::into(plane_capacity): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:253:9
[INFO] [stdout]     |
[INFO] [stdout] 253 |       let block_result =
[INFO] [stdout]     |  _________^
[INFO] [stdout] 254 | |         combine_plane_results::<Item, Leaves, Layout, Op>(value, value_valid, plane_capacity);
[INFO] [stdout] 255 | |     if block_result.1 != 0u32 {
[INFO] [stdout] 256 | |         let result = Leaves::into_cells(block_result.0);
[INFO] [stdout]     | |______________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 ~     let <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(block_result =
[INFO] [stdout] 254 |         combine_plane_results::<Item, Leaves, Layout, Op>(value, value_valid, plane_capacity);
[INFO] [stdout] 255 |     if block_result.1 != 0u32 {
[INFO] [stdout] 256 ~         let result = Leaves::into_cells(block_result.0));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]    --> src/core/reduce.rs:191:5
[INFO] [stdout]     |
[INFO] [stdout] 191 |     partial0: &mut [O0],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 191 |     <&mut cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(partial0): &mut [O0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]    --> src/core/reduce.rs:192:5
[INFO] [stdout]     |
[INFO] [stdout] 192 |     partial1: &mut [O1],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 |     <&mut cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(partial1): &mut [O1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/reduce.rs:193:5
[INFO] [stdout]     |
[INFO] [stdout] 193 |     partial2: &mut [O2],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 |     <&mut cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(partial2): &mut [O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/reduce.rs:194:5
[INFO] [stdout]     |
[INFO] [stdout] 194 |     partial3: &mut [O3],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 194 |     <&mut cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(partial3): &mut [O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/reduce.rs:195:5
[INFO] [stdout]     |
[INFO] [stdout] 195 |     partial4: &mut [O4],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 195 |     <&mut cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(partial4): &mut [O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/reduce.rs:196:5
[INFO] [stdout]     |
[INFO] [stdout] 196 |     partial5: &mut [O5],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 196 |     <&mut cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(partial5): &mut [O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/reduce.rs:197:5
[INFO] [stdout]     |
[INFO] [stdout] 197 |     partial6: &mut [O6],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     <&mut cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(partial6): &mut [O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/reduce.rs:198:5
[INFO] [stdout]     |
[INFO] [stdout] 198 |     partial7: &mut [O7],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     <&mut cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(partial7): &mut [O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/reduce.rs:199:5
[INFO] [stdout]     |
[INFO] [stdout] 199 |     partial8: &mut [O8],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 |     <&mut cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(partial8): &mut [O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/reduce.rs:200:5
[INFO] [stdout]     |
[INFO] [stdout] 200 |     partial9: &mut [O9],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 200 |     <&mut cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(partial9): &mut [O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/reduce.rs:201:5
[INFO] [stdout]     |
[INFO] [stdout] 201 |     partial10: &mut [O10],
[INFO] [stdout]     |     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 |     <&mut cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(partial10): &mut [O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/reduce.rs:202:5
[INFO] [stdout]     |
[INFO] [stdout] 202 |     partial11: &mut [O11],
[INFO] [stdout]     |     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 202 |     <&mut cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(partial11): &mut [O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/reduce.rs:190:5
[INFO] [stdout]     |
[INFO] [stdout] 190 |     zero_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 190 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(zero_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:258:17
[INFO] [stdout]     |
[INFO] [stdout] 258 |             let initial = Leaves::load_mut_padded(
[INFO] [stdout]     |                 ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 258 |             let <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(initial) = Leaves::load_mut_padded(
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:277:21
[INFO] [stdout]     |
[INFO] [stdout] 277 |                     Layout::recompose(initial),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(initial)),
[INFO] [stdout]     |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:278:39
[INFO] [stdout]     |
[INFO] [stdout] 278 |                     Layout::recompose(Leaves::read(&result)),
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 |                     Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&result))),
[INFO] [stdout]     |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:278:21
[INFO] [stdout]     |
[INFO] [stdout] 278 |                     Layout::recompose(Leaves::read(&result)),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&result))),
[INFO] [stdout]     |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:276:35
[INFO] [stdout]     |
[INFO] [stdout] 276 |                   Layout::decompose(Op::apply(
[INFO] [stdout]     |  ___________________________________^
[INFO] [stdout] 277 | |                     Layout::recompose(initial),
[INFO] [stdout] 278 | |                     Layout::recompose(Leaves::read(&result)),
[INFO] [stdout] 279 | |                 )),
[INFO] [stdout]     | |_________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 ~                 Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Op::apply(
[INFO] [stdout] 277 |                     Layout::recompose(initial),
[INFO] [stdout] 278 |                     Layout::recompose(Leaves::read(&result)),
[INFO] [stdout] 279 ~                 ))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/reduce.rs:276:17
[INFO] [stdout]     |
[INFO] [stdout] 276 | /                 Layout::decompose(Op::apply(
[INFO] [stdout] 277 | |                     Layout::recompose(initial),
[INFO] [stdout] 278 | |                     Layout::recompose(Leaves::read(&result)),
[INFO] [stdout] 279 | |                 )),
[INFO] [stdout]     | |__________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 ~                 <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(Op::apply(
[INFO] [stdout] 277 |                     Layout::recompose(initial),
[INFO] [stdout] 278 |                     Layout::recompose(Leaves::read(&result)),
[INFO] [stdout] 279 ~                 ))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:72
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,...
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0),L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:81
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,...
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1),L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:90
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,...
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2),L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:99
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,...
[INFO] [stdout]     |                                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3),L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:108
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,...
[INFO] [stdout]     |                                                                                                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4),L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:117
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,...
[INFO] [stdout]     |                                                                                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5),L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:126
[INFO] [stdout]     |
[INFO] [stdout] 386 | ...3; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6),L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:135
[INFO] [stdout]     |
[INFO] [stdout] 386 | ...ot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7),L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:144
[INFO] [stdout]     |
[INFO] [stdout] 386 | ...ot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8),L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:153
[INFO] [stdout]     |
[INFO] [stdout] 386 | ...ot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9),L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:163
[INFO] [stdout]     |
[INFO] [stdout] 386 | ...t3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10),L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:174
[INFO] [stdout]     |
[INFO] [stdout] 386 | ...,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11),L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/reduce.rs:386:185
[INFO] [stdout]     |
[INFO] [stdout] 386 | ...6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 | define_padded_reduce_eval_kernel!(padded_reduce_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12)]);
[INFO] [stdout]     |                                                                                                                                                                                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/scan/kernels.rs:11:9
[INFO] [stdout]    |
[INFO] [stdout] 11 |     let value = if global < logical_len {
[INFO] [stdout]    |         ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 11 |     let <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(value) = if global < logical_len {
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/core/scan/kernels.rs:65:17
[INFO] [stdout]    |
[INFO] [stdout] 65 |     #[comptime] plane_capacity: usize,
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 65 |     #[comptime] <usize as Into<_>>::into(plane_capacity): usize,
[INFO] [stdout]    |                 +++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:64:5
[INFO] [stdout]    |
[INFO] [stdout] 64 |     value: Item,
[INFO] [stdout]    |     ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 64 |     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(value): Item,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:74:36
[INFO] [stdout]    |
[INFO] [stdout] 74 |     let cells = Leaves::into_cells(Layout::decompose(value));
[INFO] [stdout]    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 |     let cells = Leaves::into_cells(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(value)));
[INFO] [stdout]    |                                    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:77:46
[INFO] [stdout]    |
[INFO] [stdout] 77 |         let left = Leaves::shuffle_leaves_up(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |                                              ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 77 |         let left = Leaves::shuffle_leaves_up(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&cells)), offset.read());
[INFO] [stdout]    |                                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/core/scan/kernels.rs:77:68
[INFO] [stdout]    |
[INFO] [stdout] 77 |         let left = Leaves::shuffle_leaves_up(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |                                                                    ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 77 |         let left = Leaves::shuffle_leaves_up(Leaves::read(&cells), <cubecl::frontend::NativeExpand<u32> as Into<_>>::into(offset.read()));
[INFO] [stdout]    |                                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:77:13
[INFO] [stdout]    |
[INFO] [stdout] 77 |         let left = Leaves::shuffle_leaves_up(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |             ^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 77 |         let <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(left) = Leaves::shuffle_leaves_up(Leaves::read(&cells), offset.read());
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:82:21
[INFO] [stdout]    |
[INFO] [stdout] 82 |                     Layout::recompose(left),
[INFO] [stdout]    |                     ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(left)),
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:83:39
[INFO] [stdout]    |
[INFO] [stdout] 83 |                     Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 |                     Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&cells))),
[INFO] [stdout]    |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:83:21
[INFO] [stdout]    |
[INFO] [stdout] 83 |                     Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout]    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&cells))),
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:81:35
[INFO] [stdout]    |
[INFO] [stdout] 81 |                   Layout::decompose(Op::apply(
[INFO] [stdout]    |  ___________________________________^
[INFO] [stdout] 82 | |                     Layout::recompose(left),
[INFO] [stdout] 83 | |                     Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout] 84 | |                 )),
[INFO] [stdout]    | |_________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 ~                 Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Op::apply(
[INFO] [stdout] 82 |                     Layout::recompose(left),
[INFO] [stdout] 83 |                     Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout] 84 ~                 ))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:81:17
[INFO] [stdout]    |
[INFO] [stdout] 81 | /                 Layout::decompose(Op::apply(
[INFO] [stdout] 82 | |                     Layout::recompose(left),
[INFO] [stdout] 83 | |                     Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout] 84 | |                 )),
[INFO] [stdout]    | |__________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 ~                 <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(Op::apply(
[INFO] [stdout] 82 |                     Layout::recompose(left),
[INFO] [stdout] 83 |                     Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout] 84 ~                 ))),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:90:30
[INFO] [stdout]    |
[INFO] [stdout] 90 |         Leaves::store_shared(Leaves::read(&cells), &mut shared, PLANE_POS as usize);
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 90 |         Leaves::store_shared(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&cells)), &mut shared, PLANE_POS as usize);
[INFO] [stdout]    |                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/scan/kernels.rs:95:41
[INFO] [stdout]    |
[INFO] [stdout] 95 |         let prefix = Leaves::into_cells(Leaves::load_shared(&shared, 0usize));
[INFO] [stdout]    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 |         let prefix = Leaves::into_cells(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::load_shared(&shared, 0usize)));
[INFO] [stdout]    |                                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:101:39
[INFO] [stdout]     |
[INFO] [stdout] 101 |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 101 |                     Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&prefix))),
[INFO] [stdout]     |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:101:21
[INFO] [stdout]     |
[INFO] [stdout] 101 |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 101 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&prefix))),
[INFO] [stdout]     |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:102:39
[INFO] [stdout]     |
[INFO] [stdout] 102 |                     Layout::recompose(Leaves::load_shared(&shared, plane.read() as usize)),
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 102 |                     Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::load_shared(&shared, plane.read() as usize))),
[INFO] [stdout]     |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:102:21
[INFO] [stdout]     |
[INFO] [stdout] 102 |                     Layout::recompose(Leaves::load_shared(&shared, plane.read() as usize)),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 102 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::load_shared(&shared, plane.read() as usize))),
[INFO] [stdout]     |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:100:35
[INFO] [stdout]     |
[INFO] [stdout] 100 |                   Layout::decompose(Op::apply(
[INFO] [stdout]     |  ___________________________________^
[INFO] [stdout] 101 | |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout] 102 | |                     Layout::recompose(Leaves::load_shared(&shared, plane.read() as usize)),
[INFO] [stdout] 103 | |                 )),
[INFO] [stdout]     | |_________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 ~                 Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Op::apply(
[INFO] [stdout] 101 |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout] 102 |                     Layout::recompose(Leaves::load_shared(&shared, plane.read() as usize)),
[INFO] [stdout] 103 ~                 ))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:100:17
[INFO] [stdout]     |
[INFO] [stdout] 100 | /                 Layout::decompose(Op::apply(
[INFO] [stdout] 101 | |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout] 102 | |                     Layout::recompose(Leaves::load_shared(&shared, plane.read() as usize)),
[INFO] [stdout] 103 | |                 )),
[INFO] [stdout]     | |__________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 ~                 <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(Op::apply(
[INFO] [stdout] 101 |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout] 102 |                     Layout::recompose(Leaves::load_shared(&shared, plane.read() as usize)),
[INFO] [stdout] 103 ~                 ))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:105:34
[INFO] [stdout]     |
[INFO] [stdout] 105 |             Leaves::store_shared(Leaves::read(&prefix), &mut shared, plane.read() as usize);
[INFO] [stdout]     |                                  ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 105 |             Leaves::store_shared(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&prefix)), &mut shared, plane.read() as usize);
[INFO] [stdout]     |                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:114:35
[INFO] [stdout]     |
[INFO] [stdout] 114 |                 Layout::recompose(Leaves::load_shared(&shared, PLANE_POS as usize - 1usize)),
[INFO] [stdout]     |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 114 |                 Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::load_shared(&shared, PLANE_POS as usize - 1usize))),
[INFO] [stdout]     |                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:114:17
[INFO] [stdout]     |
[INFO] [stdout] 114 |                 Layout::recompose(Leaves::load_shared(&shared, PLANE_POS as usize - 1usize)),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 114 |                 <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::load_shared(&shared, PLANE_POS as usize - 1usize))),
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:115:35
[INFO] [stdout]     |
[INFO] [stdout] 115 |                 Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout]     |                                   ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 115 |                 Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&cells))),
[INFO] [stdout]     |                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:115:17
[INFO] [stdout]     |
[INFO] [stdout] 115 |                 Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 115 |                 <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&cells))),
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:113:31
[INFO] [stdout]     |
[INFO] [stdout] 113 |               Layout::decompose(Op::apply(
[INFO] [stdout]     |  _______________________________^
[INFO] [stdout] 114 | |                 Layout::recompose(Leaves::load_shared(&shared, PLANE_POS as usize - 1usize)),
[INFO] [stdout] 115 | |                 Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout] 116 | |             )),
[INFO] [stdout]     | |_____________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 113 ~             Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Op::apply(
[INFO] [stdout] 114 |                 Layout::recompose(Leaves::load_shared(&shared, PLANE_POS as usize - 1usize)),
[INFO] [stdout] 115 |                 Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout] 116 ~             ))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:113:13
[INFO] [stdout]     |
[INFO] [stdout] 113 | /             Layout::decompose(Op::apply(
[INFO] [stdout] 114 | |                 Layout::recompose(Leaves::load_shared(&shared, PLANE_POS as usize - 1usize)),
[INFO] [stdout] 115 | |                 Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout] 116 | |             )),
[INFO] [stdout]     | |______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 113 ~             <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(Op::apply(
[INFO] [stdout] 114 |                 Layout::recompose(Leaves::load_shared(&shared, PLANE_POS as usize - 1usize)),
[INFO] [stdout] 115 |                 Layout::recompose(Leaves::read(&cells)),
[INFO] [stdout] 116 ~             ))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:63
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(slot0),L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:72
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(slot1),L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:81
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(slot2),L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:90
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(slot3),L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:99
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                                   ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(slot4),L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:108
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                                            ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(slot5),L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:117
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,...
[INFO] [stdout]     |                                                                                                                     ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(slot6),L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:126
[INFO] [stdout]     |
[INFO] [stdout] 187 | ...ot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(slot7),L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                              +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:135
[INFO] [stdout]     |
[INFO] [stdout] 187 | ...ot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(slot8),L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:144
[INFO] [stdout]     |
[INFO] [stdout] 187 | ...ot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(slot9),L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:154
[INFO] [stdout]     |
[INFO] [stdout] 187 | ...t3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(slot10),L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:165
[INFO] [stdout]     |
[INFO] [stdout] 187 | ...,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(slot11),L12:slot12]);
[INFO] [stdout]     |                                                                                                                                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:187:176
[INFO] [stdout]     |
[INFO] [stdout] 187 | ...6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:slot12]);
[INFO] [stdout]     |                                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 | define_padded_scan_kernel!(padded_scan_a13,Eval13,eval13; [L0:slot0,L1:slot1,L2:slot2,L3:slot3,L4:slot4,L5:slot5,L6:slot6,L7:slot7,L8:slot8,L9:slot9,L10:slot10,L11:slot11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(slot12)]);
[INFO] [stdout]     |                                                                                                                                                                                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:269:9
[INFO] [stdout]     |
[INFO] [stdout] 269 |     let logical_len = len[0] as usize;
[INFO] [stdout]     |         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 269 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(logical_len) = len[0] as usize;
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:239:5
[INFO] [stdout]     |
[INFO] [stdout] 239 |     input0: &[O0],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 |     <&cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(input0): &[O0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:240:5
[INFO] [stdout]     |
[INFO] [stdout] 240 |     input1: &[O1],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 |     <&cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(input1): &[O1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:241:5
[INFO] [stdout]     |
[INFO] [stdout] 241 |     input2: &[O2],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 |     <&cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(input2): &[O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:242:5
[INFO] [stdout]     |
[INFO] [stdout] 242 |     input3: &[O3],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 242 |     <&cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(input3): &[O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:243:5
[INFO] [stdout]     |
[INFO] [stdout] 243 |     input4: &[O4],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 243 |     <&cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(input4): &[O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:244:5
[INFO] [stdout]     |
[INFO] [stdout] 244 |     input5: &[O5],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 |     <&cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(input5): &[O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:245:5
[INFO] [stdout]     |
[INFO] [stdout] 245 |     input6: &[O6],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 245 |     <&cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(input6): &[O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:246:5
[INFO] [stdout]     |
[INFO] [stdout] 246 |     input7: &[O7],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 246 |     <&cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(input7): &[O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:247:5
[INFO] [stdout]     |
[INFO] [stdout] 247 |     input8: &[O8],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 247 |     <&cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(input8): &[O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:248:5
[INFO] [stdout]     |
[INFO] [stdout] 248 |     input9: &[O9],
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 248 |     <&cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(input9): &[O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:249:5
[INFO] [stdout]     |
[INFO] [stdout] 249 |     input10: &[O10],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 |     <&cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(input10): &[O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:250:5
[INFO] [stdout]     |
[INFO] [stdout] 250 |     input11: &[O11],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 250 |     <&cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(input11): &[O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:251:5
[INFO] [stdout]     |
[INFO] [stdout] 251 |     input_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 251 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(input_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:254:5
[INFO] [stdout]     |
[INFO] [stdout] 254 |     partial0: &mut [O0],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 254 |     <&mut cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(partial0): &mut [O0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:255:5
[INFO] [stdout]     |
[INFO] [stdout] 255 |     partial1: &mut [O1],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 255 |     <&mut cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(partial1): &mut [O1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:256:5
[INFO] [stdout]     |
[INFO] [stdout] 256 |     partial2: &mut [O2],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 256 |     <&mut cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(partial2): &mut [O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:257:5
[INFO] [stdout]     |
[INFO] [stdout] 257 |     partial3: &mut [O3],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 |     <&mut cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(partial3): &mut [O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:258:5
[INFO] [stdout]     |
[INFO] [stdout] 258 |     partial4: &mut [O4],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 258 |     <&mut cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(partial4): &mut [O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:259:5
[INFO] [stdout]     |
[INFO] [stdout] 259 |     partial5: &mut [O5],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 |     <&mut cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(partial5): &mut [O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:260:5
[INFO] [stdout]     |
[INFO] [stdout] 260 |     partial6: &mut [O6],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 260 |     <&mut cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(partial6): &mut [O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:261:5
[INFO] [stdout]     |
[INFO] [stdout] 261 |     partial7: &mut [O7],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 |     <&mut cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(partial7): &mut [O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:262:5
[INFO] [stdout]     |
[INFO] [stdout] 262 |     partial8: &mut [O8],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 |     <&mut cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(partial8): &mut [O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:263:5
[INFO] [stdout]     |
[INFO] [stdout] 263 |     partial9: &mut [O9],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 263 |     <&mut cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(partial9): &mut [O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:264:5
[INFO] [stdout]     |
[INFO] [stdout] 264 |     partial10: &mut [O10],
[INFO] [stdout]     |     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 |     <&mut cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(partial10): &mut [O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:265:5
[INFO] [stdout]     |
[INFO] [stdout] 265 |     partial11: &mut [O11],
[INFO] [stdout]     |     ^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 265 |     <&mut cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(partial11): &mut [O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:266:5
[INFO] [stdout]     |
[INFO] [stdout] 266 |     partial_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 266 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(partial_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:271:9
[INFO] [stdout]     |
[INFO] [stdout] 271 |     let destination = block + if exclusive { 1usize } else { 0usize };
[INFO] [stdout]     |         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(destination) = block + if exclusive { 1usize } else { 0usize };
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:398:9
[INFO] [stdout]     |
[INFO] [stdout] 398 |     let index = start + UNIT_POS as usize;
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 398 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index) = start + UNIT_POS as usize;
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:379:5
[INFO] [stdout]     |
[INFO] [stdout] 379 |     output0: &mut [O0],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 379 |     <&mut cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(output0): &mut [O0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:380:5
[INFO] [stdout]     |
[INFO] [stdout] 380 |     output1: &mut [O1],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 |     <&mut cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(output1): &mut [O1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:381:5
[INFO] [stdout]     |
[INFO] [stdout] 381 |     output2: &mut [O2],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 381 |     <&mut cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(output2): &mut [O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:382:5
[INFO] [stdout]     |
[INFO] [stdout] 382 |     output3: &mut [O3],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 |     <&mut cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(output3): &mut [O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:383:5
[INFO] [stdout]     |
[INFO] [stdout] 383 |     output4: &mut [O4],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 |     <&mut cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(output4): &mut [O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:384:5
[INFO] [stdout]     |
[INFO] [stdout] 384 |     output5: &mut [O5],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 384 |     <&mut cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(output5): &mut [O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:385:5
[INFO] [stdout]     |
[INFO] [stdout] 385 |     output6: &mut [O6],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 385 |     <&mut cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(output6): &mut [O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:386:5
[INFO] [stdout]     |
[INFO] [stdout] 386 |     output7: &mut [O7],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 |     <&mut cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(output7): &mut [O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:387:5
[INFO] [stdout]     |
[INFO] [stdout] 387 |     output8: &mut [O8],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 387 |     <&mut cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(output8): &mut [O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:388:5
[INFO] [stdout]     |
[INFO] [stdout] 388 |     output9: &mut [O9],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 |     <&mut cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(output9): &mut [O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:389:5
[INFO] [stdout]     |
[INFO] [stdout] 389 |     output10: &mut [O10],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 389 |     <&mut cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(output10): &mut [O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:390:5
[INFO] [stdout]     |
[INFO] [stdout] 390 |     output11: &mut [O11],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 390 |     <&mut cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(output11): &mut [O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:378:5
[INFO] [stdout]     |
[INFO] [stdout] 378 |     output_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 378 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(output_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:399:9
[INFO] [stdout]     |
[INFO] [stdout] 399 |     let safe_index = usize::min(index, logical_len - 1usize);
[INFO] [stdout]     |         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 399 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(safe_index) = usize::min(index, logical_len - 1usize);
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:400:36
[INFO] [stdout]     |
[INFO] [stdout] 400 |       let value = Leaves::into_cells(Leaves::load_mut_padded(
[INFO] [stdout]     |  ____________________________________^
[INFO] [stdout] 401 | |         output0,
[INFO] [stdout] 402 | |         output1,
[INFO] [stdout] 403 | |         output2,
[INFO] [stdout] ...   |
[INFO] [stdout] 414 | |         safe_index,
[INFO] [stdout] 415 | |     ));
[INFO] [stdout]     | |_____^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 400 ~     let value = Leaves::into_cells(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::load_mut_padded(
[INFO] [stdout] 401 |         output0,
[INFO] [stdout] ...
[INFO] [stdout] 414 |         safe_index,
[INFO] [stdout] 415 ~     )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:363:5
[INFO] [stdout]     |
[INFO] [stdout] 363 |     prefix0: &[O0],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 363 |     <&cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(prefix0): &[O0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:364:5
[INFO] [stdout]     |
[INFO] [stdout] 364 |     prefix1: &[O1],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 |     <&cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(prefix1): &[O1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:365:5
[INFO] [stdout]     |
[INFO] [stdout] 365 |     prefix2: &[O2],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 365 |     <&cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(prefix2): &[O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:366:5
[INFO] [stdout]     |
[INFO] [stdout] 366 |     prefix3: &[O3],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 366 |     <&cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(prefix3): &[O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:367:5
[INFO] [stdout]     |
[INFO] [stdout] 367 |     prefix4: &[O4],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 367 |     <&cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(prefix4): &[O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:368:5
[INFO] [stdout]     |
[INFO] [stdout] 368 |     prefix5: &[O5],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 368 |     <&cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(prefix5): &[O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:369:5
[INFO] [stdout]     |
[INFO] [stdout] 369 |     prefix6: &[O6],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 369 |     <&cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(prefix6): &[O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:370:5
[INFO] [stdout]     |
[INFO] [stdout] 370 |     prefix7: &[O7],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 370 |     <&cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(prefix7): &[O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:371:5
[INFO] [stdout]     |
[INFO] [stdout] 371 |     prefix8: &[O8],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 371 |     <&cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(prefix8): &[O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:372:5
[INFO] [stdout]     |
[INFO] [stdout] 372 |     prefix9: &[O9],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 372 |     <&cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(prefix9): &[O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:373:5
[INFO] [stdout]     |
[INFO] [stdout] 373 |     prefix10: &[O10],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 373 |     <&cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(prefix10): &[O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:374:5
[INFO] [stdout]     |
[INFO] [stdout] 374 |     prefix11: &[O11],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 374 |     <&cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(prefix11): &[O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/scan/kernels.rs:377:5
[INFO] [stdout]     |
[INFO] [stdout] 377 |     prefix_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(prefix_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:417:41
[INFO] [stdout]     |
[INFO] [stdout] 417 |           let prefix = Leaves::into_cells(Leaves::load_padded(
[INFO] [stdout]     |  _________________________________________^
[INFO] [stdout] 418 | |             prefix0,
[INFO] [stdout] 419 | |             prefix1,
[INFO] [stdout] 420 | |             prefix2,
[INFO] [stdout] ...   |
[INFO] [stdout] 431 | |             if exclusive { block } else { block - 1usize },
[INFO] [stdout] 432 | |         ));
[INFO] [stdout]     | |_________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 417 ~         let prefix = Leaves::into_cells(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::load_padded(
[INFO] [stdout] 418 |             prefix0,
[INFO] [stdout] ...
[INFO] [stdout] 431 |             if exclusive { block } else { block - 1usize },
[INFO] [stdout] 432 ~         )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:434:35
[INFO] [stdout]     |
[INFO] [stdout] 434 |             Leaves::store(&value, Leaves::read(&prefix));
[INFO] [stdout]     |                                   ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 434 |             Leaves::store(&value, <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&prefix)));
[INFO] [stdout]     |                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:439:39
[INFO] [stdout]     |
[INFO] [stdout] 439 |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 439 |                     Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&prefix))),
[INFO] [stdout]     |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:439:21
[INFO] [stdout]     |
[INFO] [stdout] 439 |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 439 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&prefix))),
[INFO] [stdout]     |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:440:39
[INFO] [stdout]     |
[INFO] [stdout] 440 |                     Layout::recompose(Leaves::read(&value)),
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 440 |                     Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::read(&value))),
[INFO] [stdout]     |                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:440:21
[INFO] [stdout]     |
[INFO] [stdout] 440 |                     Layout::recompose(Leaves::read(&value)),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 440 |                     <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::recompose(Leaves::read(&value))),
[INFO] [stdout]     |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:438:35
[INFO] [stdout]     |
[INFO] [stdout] 438 |                   Layout::decompose(Op::apply(
[INFO] [stdout]     |  ___________________________________^
[INFO] [stdout] 439 | |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout] 440 | |                     Layout::recompose(Leaves::read(&value)),
[INFO] [stdout] 441 | |                 )),
[INFO] [stdout]     | |_________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 438 ~                 Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Op::apply(
[INFO] [stdout] 439 |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout] 440 |                     Layout::recompose(Leaves::read(&value)),
[INFO] [stdout] 441 ~                 ))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scan/kernels.rs:438:17
[INFO] [stdout]     |
[INFO] [stdout] 438 | /                 Layout::decompose(Op::apply(
[INFO] [stdout] 439 | |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout] 440 | |                     Layout::recompose(Leaves::read(&value)),
[INFO] [stdout] 441 | |                 )),
[INFO] [stdout]     | |__________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 438 ~                 <<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Layout::decompose(Op::apply(
[INFO] [stdout] 439 |                     Layout::recompose(Leaves::read(&prefix)),
[INFO] [stdout] 440 |                     Layout::recompose(Leaves::read(&value)),
[INFO] [stdout] 441 ~                 ))),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I0]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |     index0: &[I0],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 38 |     <&cubecl::frontend::NativeExpand<[I0]> as Into<_>>::into(index0): &[I0],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I1]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:39:5
[INFO] [stdout]    |
[INFO] [stdout] 39 |     index1: &[I1],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 39 |     <&cubecl::frontend::NativeExpand<[I1]> as Into<_>>::into(index1): &[I1],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I2]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:40:5
[INFO] [stdout]    |
[INFO] [stdout] 40 |     index2: &[I2],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 40 |     <&cubecl::frontend::NativeExpand<[I2]> as Into<_>>::into(index2): &[I2],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I3]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:41:5
[INFO] [stdout]    |
[INFO] [stdout] 41 |     index3: &[I3],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 41 |     <&cubecl::frontend::NativeExpand<[I3]> as Into<_>>::into(index3): &[I3],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I4]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:42:5
[INFO] [stdout]    |
[INFO] [stdout] 42 |     index4: &[I4],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 42 |     <&cubecl::frontend::NativeExpand<[I4]> as Into<_>>::into(index4): &[I4],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I5]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:43:5
[INFO] [stdout]    |
[INFO] [stdout] 43 |     index5: &[I5],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 43 |     <&cubecl::frontend::NativeExpand<[I5]> as Into<_>>::into(index5): &[I5],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I6]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:44:5
[INFO] [stdout]    |
[INFO] [stdout] 44 |     index6: &[I6],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 |     <&cubecl::frontend::NativeExpand<[I6]> as Into<_>>::into(index6): &[I6],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I7]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:45:5
[INFO] [stdout]    |
[INFO] [stdout] 45 |     index7: &[I7],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 45 |     <&cubecl::frontend::NativeExpand<[I7]> as Into<_>>::into(index7): &[I7],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I8]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:46:5
[INFO] [stdout]    |
[INFO] [stdout] 46 |     index8: &[I8],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 |     <&cubecl::frontend::NativeExpand<[I8]> as Into<_>>::into(index8): &[I8],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I9]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:47:5
[INFO] [stdout]    |
[INFO] [stdout] 47 |     index9: &[I9],
[INFO] [stdout]    |     ^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 47 |     <&cubecl::frontend::NativeExpand<[I9]> as Into<_>>::into(index9): &[I9],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I10]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:48:5
[INFO] [stdout]    |
[INFO] [stdout] 48 |     index10: &[I10],
[INFO] [stdout]    |     ^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 48 |     <&cubecl::frontend::NativeExpand<[I10]> as Into<_>>::into(index10): &[I10],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I11]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:49:5
[INFO] [stdout]    |
[INFO] [stdout] 49 |     index11: &[I11],
[INFO] [stdout]    |     ^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 49 |     <&cubecl::frontend::NativeExpand<[I11]> as Into<_>>::into(index11): &[I11],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[I12]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:50:5
[INFO] [stdout]    |
[INFO] [stdout] 50 |     index12: &[I12],
[INFO] [stdout]    |     ^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 |     <&cubecl::frontend::NativeExpand<[I12]> as Into<_>>::into(index12): &[I12],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:51:5
[INFO] [stdout]    |
[INFO] [stdout] 51 |     index_offsets: &[u32],
[INFO] [stdout]    |     ^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(index_offsets): &[u32],
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/core/scatter_reduce.rs:62:17
[INFO] [stdout]    |
[INFO] [stdout] 62 |             let index_position = order[positions[position] as usize] as usize;
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 |             let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(index_position) = order[positions[position] as usize] as usize;
[INFO] [stdout]    |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:136:5
[INFO] [stdout]     |
[INFO] [stdout] 136 |     source0: &[L0],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 |     <&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(source0): &[L0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:137:5
[INFO] [stdout]     |
[INFO] [stdout] 137 |     source1: &[L1],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 137 |     <&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(source1): &[L1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:138:5
[INFO] [stdout]     |
[INFO] [stdout] 138 |     source2: &[L2],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 |     <&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(source2): &[L2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:139:5
[INFO] [stdout]     |
[INFO] [stdout] 139 |     source3: &[L3],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 139 |     <&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(source3): &[L3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:140:5
[INFO] [stdout]     |
[INFO] [stdout] 140 |     source4: &[L4],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 140 |     <&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(source4): &[L4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:141:5
[INFO] [stdout]     |
[INFO] [stdout] 141 |     source5: &[L5],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 |     <&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(source5): &[L5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:142:5
[INFO] [stdout]     |
[INFO] [stdout] 142 |     source6: &[L6],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |     <&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(source6): &[L6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:143:5
[INFO] [stdout]     |
[INFO] [stdout] 143 |     source7: &[L7],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 |     <&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(source7): &[L7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:144:5
[INFO] [stdout]     |
[INFO] [stdout] 144 |     source8: &[L8],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 144 |     <&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(source8): &[L8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:145:5
[INFO] [stdout]     |
[INFO] [stdout] 145 |     source9: &[L9],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 |     <&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(source9): &[L9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 146 |     source10: &[L10],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 146 |     <&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(source10): &[L10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:147:5
[INFO] [stdout]     |
[INFO] [stdout] 147 |     source11: &[L11],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 147 |     <&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(source11): &[L11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:148:5
[INFO] [stdout]     |
[INFO] [stdout] 148 |     source12: &[L12],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 148 |     <&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(source12): &[L12],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:149:5
[INFO] [stdout]     |
[INFO] [stdout] 149 |     source_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(source_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:165:9
[INFO] [stdout]     |
[INFO] [stdout] 165 |     let position = ABSOLUTE_POS as usize;
[INFO] [stdout]     |         ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |     let <cubecl::frontend::NativeExpand<usize> as Into<_>>::into(position) = ABSOLUTE_POS as usize;
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O0]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:151:5
[INFO] [stdout]     |
[INFO] [stdout] 151 |     output0: &mut [O0],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 |     <&mut cubecl::frontend::NativeExpand<[O0]> as Into<_>>::into(output0): &mut [O0],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O1]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:152:5
[INFO] [stdout]     |
[INFO] [stdout] 152 |     output1: &mut [O1],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 152 |     <&mut cubecl::frontend::NativeExpand<[O1]> as Into<_>>::into(output1): &mut [O1],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O2]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:153:5
[INFO] [stdout]     |
[INFO] [stdout] 153 |     output2: &mut [O2],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 153 |     <&mut cubecl::frontend::NativeExpand<[O2]> as Into<_>>::into(output2): &mut [O2],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O3]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:154:5
[INFO] [stdout]     |
[INFO] [stdout] 154 |     output3: &mut [O3],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 |     <&mut cubecl::frontend::NativeExpand<[O3]> as Into<_>>::into(output3): &mut [O3],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O4]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:155:5
[INFO] [stdout]     |
[INFO] [stdout] 155 |     output4: &mut [O4],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 155 |     <&mut cubecl::frontend::NativeExpand<[O4]> as Into<_>>::into(output4): &mut [O4],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O5]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:156:5
[INFO] [stdout]     |
[INFO] [stdout] 156 |     output5: &mut [O5],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 156 |     <&mut cubecl::frontend::NativeExpand<[O5]> as Into<_>>::into(output5): &mut [O5],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O6]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:157:5
[INFO] [stdout]     |
[INFO] [stdout] 157 |     output6: &mut [O6],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 157 |     <&mut cubecl::frontend::NativeExpand<[O6]> as Into<_>>::into(output6): &mut [O6],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O7]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:158:5
[INFO] [stdout]     |
[INFO] [stdout] 158 |     output7: &mut [O7],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 |     <&mut cubecl::frontend::NativeExpand<[O7]> as Into<_>>::into(output7): &mut [O7],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O8]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:159:5
[INFO] [stdout]     |
[INFO] [stdout] 159 |     output8: &mut [O8],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 159 |     <&mut cubecl::frontend::NativeExpand<[O8]> as Into<_>>::into(output8): &mut [O8],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O9]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:160:5
[INFO] [stdout]     |
[INFO] [stdout] 160 |     output9: &mut [O9],
[INFO] [stdout]     |     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 160 |     <&mut cubecl::frontend::NativeExpand<[O9]> as Into<_>>::into(output9): &mut [O9],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O10]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:161:5
[INFO] [stdout]     |
[INFO] [stdout] 161 |     output10: &mut [O10],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 161 |     <&mut cubecl::frontend::NativeExpand<[O10]> as Into<_>>::into(output10): &mut [O10],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl::frontend::NativeExpand<[O11]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:162:5
[INFO] [stdout]     |
[INFO] [stdout] 162 |     output11: &mut [O11],
[INFO] [stdout]     |     ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 |     <&mut cubecl::frontend::NativeExpand<[O11]> as Into<_>>::into(output11): &mut [O11],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[u32]>`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:163:5
[INFO] [stdout]     |
[INFO] [stdout] 163 |     output_offsets: &[u32],
[INFO] [stdout]     |     ^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 |     <&cubecl::frontend::NativeExpand<[u32]> as Into<_>>::into(output_offsets): &[u32],
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Leaves as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:187:46
[INFO] [stdout]     |
[INFO] [stdout] 187 |               let previous = Layout::recompose(Leaves::load_mut_padded(
[INFO] [stdout]     |  ______________________________________________^
[INFO] [stdout] 188 | |                 output0,
[INFO] [stdout] 189 | |                 output1,
[INFO] [stdout] 190 | |                 output2,
[INFO] [stdout] ...   |
[INFO] [stdout] 201 | |                 destination as usize,
[INFO] [stdout] 202 | |             ));
[INFO] [stdout]     | |_____________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 ~             let previous = Layout::recompose(<<Leaves as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Leaves::load_mut_padded(
[INFO] [stdout] 188 |                 output0,
[INFO] [stdout] ...
[INFO] [stdout] 201 |                 destination as usize,
[INFO] [stdout] 202 ~             )));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:187:17
[INFO] [stdout]     |
[INFO] [stdout] 187 |             let previous = Layout::recompose(Leaves::load_mut_padded(
[INFO] [stdout]     |                 ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 |             let <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(previous) = Layout::recompose(Leaves::load_mut_padded(
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:170:17
[INFO] [stdout]     |
[INFO] [stdout] 170 |             let proposal = SourceExpr::eval13(
[INFO] [stdout]     |                 ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 170 |             let <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(proposal) = SourceExpr::eval13(
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/core/scatter_reduce.rs:203:31
[INFO] [stdout]     |
[INFO] [stdout] 203 |             Layout::decompose(Op::apply(previous, proposal)).store_padded(
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 |             Layout::decompose(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(Op::apply(previous, proposal))).store_padded(
[INFO] [stdout]     |                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/search.rs:63:13
[INFO] [stdout]    |
[INFO] [stdout] 63 |     fn code(left: Item, right: Item, _left_again: Item, _right_again: Item) -> u32 {
[INFO] [stdout]    |             ^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 |     fn code(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(left): Item, right: Item, _left_again: Item, _right_again: Item) -> u32 {
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/search.rs:63:25
[INFO] [stdout]    |
[INFO] [stdout] 63 |     fn code(left: Item, right: Item, _left_again: Item, _right_again: Item) -> u32 {
[INFO] [stdout]    |                         ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 |     fn code(left: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(right): Item, _left_again: Item, _right_again: Item) -> u32 {
[INFO] [stdout]    |                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/search.rs:80:13
[INFO] [stdout]    |
[INFO] [stdout] 80 |     fn code(left: Item, right: Item, left_again: Item, right_again: Item) -> u32 {
[INFO] [stdout]    |             ^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 |     fn code(<<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(left): Item, right: Item, left_again: Item, right_again: Item) -> u32 {
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/search.rs:80:25
[INFO] [stdout]    |
[INFO] [stdout] 80 |     fn code(left: Item, right: Item, left_again: Item, right_again: Item) -> u32 {
[INFO] [stdout]    |                         ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 |     fn code(left: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(right): Item, left_again: Item, right_again: Item) -> u32 {
[INFO] [stdout]    |                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/search.rs:80:56
[INFO] [stdout]    |
[INFO] [stdout] 80 |     fn code(left: Item, right: Item, left_again: Item, right_again: Item) -> u32 {
[INFO] [stdout]    |                                                        ^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 |     fn code(left: Item, right: Item, left_again: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(right_again): Item) -> u32 {
[INFO] [stdout]    |                                                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<Item as cubecl::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/core/search.rs:80:38
[INFO] [stdout]    |
[INFO] [stdout] 80 |     fn code(left: Item, right: Item, left_again: Item, right_again: Item) -> u32 {
[INFO] [stdout]    |                                      ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 |     fn code(left: Item, right: Item, <<Item as cubecl::frontend::CubeType>::ExpandType as Into<_>>::into(left_again): Item, right_again: Item) -> u32 {
[INFO] [stdout]    |                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/search.rs:127:9
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |         ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(left0),L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/search.rs:127:18
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                  ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(left1),L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/search.rs:127:27
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                           ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(left2),L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                           +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/search.rs:127:36
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                    ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(left3),L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/search.rs:127:45
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                             ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(left4),L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/search.rs:127:54
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                      ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(left5),L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/search.rs:127:63
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                               ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(left6),L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/search.rs:127:72
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                        ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(left7),L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/search.rs:127:81
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                                 ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(left8),L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/search.rs:127:90
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                                          ^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(left9),L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/search.rs:127:100
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                                                    ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(left10),L11:left11,L12:left12];
[INFO] [stdout]     |                                                                                                    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/search.rs:127:111
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                                                               ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(left11),L12:left12];
[INFO] [stdout]     |                                                                                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/search.rs:127:122
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:left12];
[INFO] [stdout]     |                                                                                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 |     [L0:left0,L1:left1,L2:left2,L3:left3,L4:left4,L5:left5,L6:left6,L7:left7,L8:left8,L9:left9,L10:left10,L11:left11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(left12)];
[INFO] [stdout]     |                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R0]>`
[INFO] [stdout]    --> src/core/search.rs:128:9
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:<&cubecl::frontend::NativeExpand<[R0]> as Into<_>>::into(right0),R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R1]>`
[INFO] [stdout]    --> src/core/search.rs:128:19
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                   ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:<&cubecl::frontend::NativeExpand<[R1]> as Into<_>>::into(right1),R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R2]>`
[INFO] [stdout]    --> src/core/search.rs:128:29
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                             ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:<&cubecl::frontend::NativeExpand<[R2]> as Into<_>>::into(right2),R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R3]>`
[INFO] [stdout]    --> src/core/search.rs:128:39
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:<&cubecl::frontend::NativeExpand<[R3]> as Into<_>>::into(right3),R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                                       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R4]>`
[INFO] [stdout]    --> src/core/search.rs:128:49
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                                 ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:<&cubecl::frontend::NativeExpand<[R4]> as Into<_>>::into(right4),R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R5]>`
[INFO] [stdout]    --> src/core/search.rs:128:59
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                                           ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:<&cubecl::frontend::NativeExpand<[R5]> as Into<_>>::into(right5),R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                                                           +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R6]>`
[INFO] [stdout]    --> src/core/search.rs:128:69
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                                                     ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:<&cubecl::frontend::NativeExpand<[R6]> as Into<_>>::into(right6),R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R7]>`
[INFO] [stdout]    --> src/core/search.rs:128:79
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                                                               ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:<&cubecl::frontend::NativeExpand<[R7]> as Into<_>>::into(right7),R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                                                                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R8]>`
[INFO] [stdout]    --> src/core/search.rs:128:89
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                                                                         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:<&cubecl::frontend::NativeExpand<[R8]> as Into<_>>::into(right8),R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                                                                                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R9]>`
[INFO] [stdout]    --> src/core/search.rs:128:99
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                                                                                   ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:<&cubecl::frontend::NativeExpand<[R9]> as Into<_>>::into(right9),R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                                                                                                   +++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R10]>`
[INFO] [stdout]    --> src/core/search.rs:128:110
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                                                                                              ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:<&cubecl::frontend::NativeExpand<[R10]> as Into<_>>::into(right10),R11:right11,R12:right12]
[INFO] [stdout]     |                                                                                                              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R11]>`
[INFO] [stdout]    --> src/core/search.rs:128:122
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R1...
[INFO] [stdout]     |                                                                                                                          ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:<&cubecl::frontend::NativeExpand<[R11]> as Into<_>>::into(right11),R12:right12]
[INFO] [stdout]     |                                                                                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R12]>`
[INFO] [stdout]    --> src/core/search.rs:128:134
[INFO] [stdout]     |
[INFO] [stdout] 128 | ...6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:right12]
[INFO] [stdout]     |                                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 128 |     [R0:right0,R1:right1,R2:right2,R3:right3,R4:right4,R5:right5,R6:right6,R7:right7,R8:right8,R9:right9,R10:right10,R11:right11,R12:<&cubecl::frontend::NativeExpand<[R12]> as Into<_>>::into(right12)]
[INFO] [stdout]     |                                                                                                                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L0]>`
[INFO] [stdout]    --> src/core/search.rs:197:9
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |         ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:<&cubecl::frontend::NativeExpand<[L0]> as Into<_>>::into(source0),L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L1]>`
[INFO] [stdout]    --> src/core/search.rs:197:20
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                    ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:<&cubecl::frontend::NativeExpand<[L1]> as Into<_>>::into(source1),L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L2]>`
[INFO] [stdout]    --> src/core/search.rs:197:31
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                               ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:<&cubecl::frontend::NativeExpand<[L2]> as Into<_>>::into(source2),L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L3]>`
[INFO] [stdout]    --> src/core/search.rs:197:42
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                                          ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:<&cubecl::frontend::NativeExpand<[L3]> as Into<_>>::into(source3),L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L4]>`
[INFO] [stdout]    --> src/core/search.rs:197:53
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                                                     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:<&cubecl::frontend::NativeExpand<[L4]> as Into<_>>::into(source4),L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L5]>`
[INFO] [stdout]    --> src/core/search.rs:197:64
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:<&cubecl::frontend::NativeExpand<[L5]> as Into<_>>::into(source5),L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                                                +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L6]>`
[INFO] [stdout]    --> src/core/search.rs:197:75
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                                                                           ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:<&cubecl::frontend::NativeExpand<[L6]> as Into<_>>::into(source6),L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                                                           +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L7]>`
[INFO] [stdout]    --> src/core/search.rs:197:86
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                                                                                      ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:<&cubecl::frontend::NativeExpand<[L7]> as Into<_>>::into(source7),L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L8]>`
[INFO] [stdout]    --> src/core/search.rs:197:97
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                                                                                                 ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:<&cubecl::frontend::NativeExpand<[L8]> as Into<_>>::into(source8),L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L9]>`
[INFO] [stdout]    --> src/core/search.rs:197:108
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                                                                                                            ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:<&cubecl::frontend::NativeExpand<[L9]> as Into<_>>::into(source9),L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                                                                                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L10]>`
[INFO] [stdout]    --> src/core/search.rs:197:120
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11...
[INFO] [stdout]     |                                                                                                                        ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:<&cubecl::frontend::NativeExpand<[L10]> as Into<_>>::into(source10),L11:source11,L12:source12];
[INFO] [stdout]     |                                                                                                                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L11]>`
[INFO] [stdout]    --> src/core/search.rs:197:133
[INFO] [stdout]     |
[INFO] [stdout] 197 | ...6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                                                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:<&cubecl::frontend::NativeExpand<[L11]> as Into<_>>::into(source11),L12:source12];
[INFO] [stdout]     |                                                                                                                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[L12]>`
[INFO] [stdout]    --> src/core/search.rs:197:146
[INFO] [stdout]     |
[INFO] [stdout] 197 | ...source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:source12];
[INFO] [stdout]     |                                                                ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     [L0:source0,L1:source1,L2:source2,L3:source3,L4:source4,L5:source5,L6:source6,L7:source7,L8:source8,L9:source9,L10:source10,L11:source11,L12:<&cubecl::frontend::NativeExpand<[L12]> as Into<_>>::into(source12)];
[INFO] [stdout]     |                                                                                                                                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R0]>`
[INFO] [stdout]    --> src/core/search.rs:198:9
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |         ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:<&cubecl::frontend::NativeExpand<[R0]> as Into<_>>::into(needle0),R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R1]>`
[INFO] [stdout]    --> src/core/search.rs:198:20
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |                    ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:<&cubecl::frontend::NativeExpand<[R1]> as Into<_>>::into(needle1),R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R2]>`
[INFO] [stdout]    --> src/core/search.rs:198:31
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |                               ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:<&cubecl::frontend::NativeExpand<[R2]> as Into<_>>::into(needle2),R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |                               +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R3]>`
[INFO] [stdout]    --> src/core/search.rs:198:42
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |                                          ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:<&cubecl::frontend::NativeExpand<[R3]> as Into<_>>::into(needle3),R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R4]>`
[INFO] [stdout]    --> src/core/search.rs:198:53
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |                                                     ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:<&cubecl::frontend::NativeExpand<[R4]> as Into<_>>::into(needle4),R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |                                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R5]>`
[INFO] [stdout]    --> src/core/search.rs:198:64
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |                                                                ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:<&cubecl::frontend::NativeExpand<[R5]> as Into<_>>::into(needle5),R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |                                                                +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R6]>`
[INFO] [stdout]    --> src/core/search.rs:198:75
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |                                                                           ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:<&cubecl::frontend::NativeExpand<[R6]> as Into<_>>::into(needle6),R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |                                                                           +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R7]>`
[INFO] [stdout]    --> src/core/search.rs:198:86
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |                                                                                      ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:<&cubecl::frontend::NativeExpand<[R7]> as Into<_>>::into(needle7),R8:needle8,R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |                                                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R8]>`
[INFO] [stdout]    --> src/core/search.rs:198:97
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:needle8,R9:needle9,R10:needle10,R11...
[INFO] [stdout]     |                                                                                                 ^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 |     [R0:needle0,R1:needle1,R2:needle2,R3:needle3,R4:needle4,R5:needle5,R6:needle6,R7:needle7,R8:<&cubecl::frontend::NativeExpand<[R8]> as Into<_>>::into(needle8),R9:needle9,R10:needle10,R11:needle11,R12:needle12]
[INFO] [stdout]     |                                                                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl::frontend::NativeExpand<[R9]>`
[WARN] too many lines in the log, truncating it
