From 37a60f89226faebd08ac6384568982e3be998248 Mon Sep 17 00:00:00 2001
From: "Sergey \"Shnatsel\" Davidoff" <shnatsel@gmail.com>
Date: Thu, 30 Jul 2026 15:23:46 +0100
Subject: [PATCH 1/8] Add swizzle_dyn that does not zero out-of-bounds indices,
 faster than swizzle_dyn_precise on x86
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Throughput improves only slightly, but latencies improve significantly:

| Backend / model | Precise | Relaxed | Change |
|---|---:|---:|---:|
| SSE4.2 / Westmere | 14 cycles | 11 cycles | −3 |
| AVX2 / Haswell | 18 cycles | 18 cycles | unchanged |
| AVX-512 / Ice Lake | 26 cycles | 15 cycles | −11 |

The fallback implementation is also much faster thanks to eliminating branching.
---
 CHANGELOG.md                                 |    1 +
 fearless_simd/src/generated/avx2.rs          |  390 ++
 fearless_simd/src/generated/avx512.rs        |  420 ++
 fearless_simd/src/generated/fallback.rs      | 5568 ++++++++++++++++--
 fearless_simd/src/generated/neon.rs          |  120 +
 fearless_simd/src/generated/simd_trait.rs    |   62 +
 fearless_simd/src/generated/simd_types.rs    |  150 +
 fearless_simd/src/generated/sse2.rs          | 5568 ++++++++++++++++--
 fearless_simd/src/generated/sse4_2.rs        | 3804 ++++++++++--
 fearless_simd/src/generated/wasm.rs          |  120 +
 fearless_simd_gen/src/generic.rs             |   13 +-
 fearless_simd_gen/src/mk_fallback.rs         |   32 +
 fearless_simd_gen/src/mk_neon.rs             |    3 +
 fearless_simd_gen/src/mk_simd_types.rs       |    6 +
 fearless_simd_gen/src/mk_wasm.rs             |    3 +
 fearless_simd_gen/src/mk_x86.rs              |   69 +
 fearless_simd_gen/src/ops.rs                 |   33 +-
 fearless_simd_tests/tests/harness/ops/mod.rs |    1 +
 18 files changed, 15014 insertions(+), 1349 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3308f9af..49d40630 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@ You can find its changes [documented below](#060-2026-07-10).
 ### Added
 
 - Added an `Sse2` level. This is the new baseline for i686-* and x86_64-* targets, replacing `Fallback`. ([#270][] by [@Shnatsel][])
+- Added full-vector `swizzle_dyn` and `swizzle_dyn_precise` byte swizzles. `swizzle_dyn` permits implementation-defined results for out-of-range indices, while `swizzle_dyn_precise` always returns zero for them.
 
 ### Changed
 
diff --git a/fearless_simd/src/generated/avx2.rs b/fearless_simd/src/generated/avx2.rs
index 3aa426bd..d88a2977 100644
--- a/fearless_simd/src/generated/avx2.rs
+++ b/fearless_simd/src/generated/avx2.rs
@@ -242,6 +242,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: f32x4<Avx2>, indices: u8x16<Avx2>) -> f32x4<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -842,6 +856,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: i8x16<Avx2>, indices: u8x16<Avx2>) -> i8x16<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -1348,6 +1376,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: u8x16<Avx2>, indices: u8x16<Avx2>) -> u8x16<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -2005,6 +2047,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: i16x8<Avx2>, indices: u8x16<Avx2>) -> i16x8<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -2440,6 +2496,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: u16x8<Avx2>, indices: u8x16<Avx2>) -> u16x8<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -3036,6 +3106,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: i32x4<Avx2>, indices: u8x16<Avx2>) -> i32x4<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -3455,6 +3539,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: u32x4<Avx2>, indices: u8x16<Avx2>) -> u32x4<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4049,6 +4147,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: f64x2<Avx2>, indices: u8x16<Avx2>) -> f64x2<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4510,6 +4622,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: i64x2<Avx2>, indices: u8x16<Avx2>) -> i64x2<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4896,6 +5022,20 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: u64x2<Avx2>, indices: u8x16<Avx2>) -> u64x2<Avx2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -5477,6 +5617,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: f32x8<Avx2>, indices: u8x32<Avx2>) -> f32x8<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -6209,6 +6370,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: i8x32<Avx2>, indices: u8x32<Avx2>) -> i8x32<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -6900,6 +7082,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: u8x32<Avx2>, indices: u8x32<Avx2>) -> u8x32<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -7732,6 +7935,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: i16x16<Avx2>, indices: u8x32<Avx2>) -> i16x16<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -8314,6 +8538,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: u16x16<Avx2>, indices: u8x32<Avx2>) -> u16x16<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9068,6 +9313,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: i32x8<Avx2>, indices: u8x32<Avx2>) -> i32x8<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9574,6 +9840,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: u32x8<Avx2>, indices: u8x32<Avx2>) -> u32x8<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -10259,6 +10546,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: f64x4<Avx2>, indices: u8x32<Avx2>) -> f64x4<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -10788,6 +11096,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: i64x4<Avx2>, indices: u8x32<Avx2>) -> i64x4<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -11256,6 +11585,27 @@ impl Simd for Avx2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx2, a: u64x4<Avx2>, indices: u8x32<Avx2>) -> u64x4<Avx2> {
+                let bytes = Bytes::to_bytes(a).val.0;
+                let indices = indices.into();
+                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                let select_high = _mm256_slli_epi16::<3>(indices);
+                let from_low = _mm256_shuffle_epi8(lolo, indices);
+                let from_high = _mm256_shuffle_epi8(hihi, indices);
+                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -11925,6 +12275,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+        self.swizzle_dyn_precise_f32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -12649,6 +13003,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
+        self.swizzle_dyn_precise_i8x64(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -13221,6 +13579,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
+        self.swizzle_dyn_precise_u8x64(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -13901,6 +14263,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
+        self.swizzle_dyn_precise_i16x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -14355,6 +14721,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
+        self.swizzle_dyn_precise_u16x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -14971,6 +15341,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
+        self.swizzle_dyn_precise_i32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -15360,6 +15734,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
+        self.swizzle_dyn_precise_u32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -15921,6 +16299,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
+        self.swizzle_dyn_precise_f64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -16320,6 +16702,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
+        self.swizzle_dyn_precise_i64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -16668,6 +17054,10 @@ impl Simd for Avx2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
+        self.swizzle_dyn_precise_u64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         crate::kernel!(
             #[inline(always)]
diff --git a/fearless_simd/src/generated/avx512.rs b/fearless_simd/src/generated/avx512.rs
index 60a23392..824059c9 100644
--- a/fearless_simd/src/generated/avx512.rs
+++ b/fearless_simd/src/generated/avx512.rs
@@ -253,6 +253,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: f32x4<Avx512>, indices: u8x16<Avx512>) -> f32x4<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -851,6 +865,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i8x16<Avx512>, indices: u8x16<Avx512>) -> i8x16<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -1397,6 +1425,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u8x16<Avx512>, indices: u8x16<Avx512>) -> u8x16<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -2043,6 +2085,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i16x8<Avx512>, indices: u8x16<Avx512>) -> i16x8<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -2507,6 +2563,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u16x8<Avx512>, indices: u8x16<Avx512>) -> u16x8<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -3080,6 +3150,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i32x4<Avx512>, indices: u8x16<Avx512>) -> i32x4<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -3528,6 +3612,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u32x4<Avx512>, indices: u8x16<Avx512>) -> u32x4<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4094,6 +4192,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: f64x2<Avx512>, indices: u8x16<Avx512>) -> f64x2<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4583,6 +4695,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i64x2<Avx512>, indices: u8x16<Avx512>) -> i64x2<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -5011,6 +5137,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u64x2<Avx512>, indices: u8x16<Avx512>) -> u64x2<Avx512> {
+                let result = _mm_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -5617,6 +5757,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: f32x8<Avx512>, indices: u8x32<Avx512>) -> f32x8<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -6380,6 +6534,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i8x32<Avx512>, indices: u8x32<Avx512>) -> i8x32<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -7097,6 +7265,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u8x32<Avx512>, indices: u8x32<Avx512>) -> u8x32<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -7900,6 +8082,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i16x16<Avx512>, indices: u8x32<Avx512>) -> i16x16<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -8491,6 +8687,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u16x16<Avx512>, indices: u8x32<Avx512>) -> u16x16<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9195,6 +9405,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i32x8<Avx512>, indices: u8x32<Avx512>) -> i32x8<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9738,6 +9962,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u32x8<Avx512>, indices: u8x32<Avx512>) -> u32x8<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -10405,6 +10643,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: f64x4<Avx512>, indices: u8x32<Avx512>) -> f64x4<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -10981,6 +11233,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i64x4<Avx512>, indices: u8x32<Avx512>) -> i64x4<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -11482,6 +11748,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u64x4<Avx512>, indices: u8x32<Avx512>) -> u64x4<Avx512> {
+                let result = _mm256_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x32 {
+                    val: crate::support::Aligned256(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -12175,6 +12455,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: f32x16<Avx512>, indices: u8x64<Avx512>) -> f32x16<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -13109,6 +13403,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i8x64<Avx512>, indices: u8x64<Avx512>) -> i8x64<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -13962,6 +14270,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u8x64<Avx512>, indices: u8x64<Avx512>) -> u8x64<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -14858,6 +15180,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i16x32<Avx512>, indices: u8x64<Avx512>) -> i16x32<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -15522,6 +15858,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u16x32<Avx512>, indices: u8x64<Avx512>) -> u16x32<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -16299,6 +16649,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i32x16<Avx512>, indices: u8x64<Avx512>) -> i32x16<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -16891,6 +17255,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u32x16<Avx512>, indices: u8x64<Avx512>) -> u32x16<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -17608,6 +17986,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: f64x8<Avx512>, indices: u8x64<Avx512>) -> f64x8<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -18211,6 +18603,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: i64x8<Avx512>, indices: u8x64<Avx512>) -> i64x8<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -18735,6 +19141,20 @@ impl Simd for Avx512 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Avx512, a: u64x8<Avx512>, indices: u8x64<Avx512>) -> u64x8<Avx512> {
+                let result = _mm512_permutexvar_epi8(indices.into(), Bytes::to_bytes(a).val.0);
+                Bytes::from_bytes(u8x64 {
+                    val: crate::support::Aligned512(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         crate::kernel!(
             #[inline(always)]
diff --git a/fearless_simd/src/generated/fallback.rs b/fearless_simd/src/generated/fallback.rs
index b10723f6..3c513d37 100644
--- a/fearless_simd/src/generated/fallback.rs
+++ b/fearless_simd/src/generated/fallback.rs
@@ -338,6 +338,78 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -900,6 +972,78 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -1687,6 +1831,78 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -2788,50 +3004,122 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+    fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 16usize];
-        for lane in 0..16usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 16usize];
-            output[lane] = if index < 16usize { value } else { 0 };
-        }
-        let result: u8x16<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
-        [
-            i16::wrapping_add(a[0usize], b[0usize]),
-            i16::wrapping_add(a[1usize], b[1usize]),
-            i16::wrapping_add(a[2usize], b[2usize]),
-            i16::wrapping_add(a[3usize], b[3usize]),
-            i16::wrapping_add(a[4usize], b[4usize]),
-            i16::wrapping_add(a[5usize], b[5usize]),
-            i16::wrapping_add(a[6usize], b[6usize]),
-            i16::wrapping_add(a[7usize], b[7usize]),
-        ]
-        .simd_into(self)
-    }
-    #[inline(always)]
-    fn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
-        [
-            i16::wrapping_sub(a[0usize], b[0usize]),
-            i16::wrapping_sub(a[1usize], b[1usize]),
-            i16::wrapping_sub(a[2usize], b[2usize]),
-            i16::wrapping_sub(a[3usize], b[3usize]),
-            i16::wrapping_sub(a[4usize], b[4usize]),
-            i16::wrapping_sub(a[5usize], b[5usize]),
-            i16::wrapping_sub(a[6usize], b[6usize]),
-            i16::wrapping_sub(a[7usize], b[7usize]),
-        ]
-        .simd_into(self)
-    }
-    #[inline(always)]
-    fn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
-        [
-            i16::wrapping_mul(a[0usize], b[0usize]),
-            i16::wrapping_mul(a[1usize], b[1usize]),
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 16usize];
+            output[lane] = if index < 16usize { value } else { 0 };
+        }
+        let result: u8x16<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
+        [
+            i16::wrapping_add(a[0usize], b[0usize]),
+            i16::wrapping_add(a[1usize], b[1usize]),
+            i16::wrapping_add(a[2usize], b[2usize]),
+            i16::wrapping_add(a[3usize], b[3usize]),
+            i16::wrapping_add(a[4usize], b[4usize]),
+            i16::wrapping_add(a[5usize], b[5usize]),
+            i16::wrapping_add(a[6usize], b[6usize]),
+            i16::wrapping_add(a[7usize], b[7usize]),
+        ]
+        .simd_into(self)
+    }
+    #[inline(always)]
+    fn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
+        [
+            i16::wrapping_sub(a[0usize], b[0usize]),
+            i16::wrapping_sub(a[1usize], b[1usize]),
+            i16::wrapping_sub(a[2usize], b[2usize]),
+            i16::wrapping_sub(a[3usize], b[3usize]),
+            i16::wrapping_sub(a[4usize], b[4usize]),
+            i16::wrapping_sub(a[5usize], b[5usize]),
+            i16::wrapping_sub(a[6usize], b[6usize]),
+            i16::wrapping_sub(a[7usize], b[7usize]),
+        ]
+        .simd_into(self)
+    }
+    #[inline(always)]
+    fn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
+        [
+            i16::wrapping_mul(a[0usize], b[0usize]),
+            i16::wrapping_mul(a[1usize], b[1usize]),
             i16::wrapping_mul(a[2usize], b[2usize]),
             i16::wrapping_mul(a[3usize], b[3usize]),
             i16::wrapping_mul(a[4usize], b[4usize]),
@@ -3344,6 +3632,78 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -4096,6 +4456,78 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -4538,6 +4970,78 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -5116,6 +5620,78 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -5500,6 +6076,78 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -5868,50 +6516,122 @@ impl Simd for Fallback {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+    fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 16usize];
-        for lane in 0..16usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 16usize];
-            output[lane] = if index < 16usize { value } else { 0 };
-        }
-        let result: u8x16<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
-        [
-            u64::wrapping_add(a[0usize], b[0usize]),
-            u64::wrapping_add(a[1usize], b[1usize]),
-        ]
-        .simd_into(self)
-    }
-    #[inline(always)]
-    fn sub_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
-        [
-            u64::wrapping_sub(a[0usize], b[0usize]),
-            u64::wrapping_sub(a[1usize], b[1usize]),
-        ]
-        .simd_into(self)
-    }
-    #[inline(always)]
-    fn mul_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
-        [
-            u64::wrapping_mul(a[0usize], b[0usize]),
-            u64::wrapping_mul(a[1usize], b[1usize]),
-        ]
-        .simd_into(self)
-    }
-    #[inline(always)]
-    fn and_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
-        [
-            u64::bitand(a[0usize], &b[0usize]),
-            u64::bitand(a[1usize], &b[1usize]),
-        ]
-        .simd_into(self)
-    }
-    #[inline(always)]
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 16usize];
+            output[lane] = if index < 16usize { value } else { 0 };
+        }
+        let result: u8x16<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
+        [
+            u64::wrapping_add(a[0usize], b[0usize]),
+            u64::wrapping_add(a[1usize], b[1usize]),
+        ]
+        .simd_into(self)
+    }
+    #[inline(always)]
+    fn sub_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
+        [
+            u64::wrapping_sub(a[0usize], b[0usize]),
+            u64::wrapping_sub(a[1usize], b[1usize]),
+        ]
+        .simd_into(self)
+    }
+    #[inline(always)]
+    fn mul_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
+        [
+            u64::wrapping_mul(a[0usize], b[0usize]),
+            u64::wrapping_mul(a[1usize], b[1usize]),
+        ]
+        .simd_into(self)
+    }
+    #[inline(always)]
+    fn and_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
+        [
+            u64::bitand(a[0usize], &b[0usize]),
+            u64::bitand(a[1usize], &b[1usize]),
+        ]
+        .simd_into(self)
+    }
+    #[inline(always)]
     fn or_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
         [
             u64::bitor(a[0usize], &b[0usize]),
@@ -6327,6 +7047,142 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -6826,63 +7682,199 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+    fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.add_i8x16(a0, b0), self.add_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.sub_i8x16(a0, b0), self.sub_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.mul_i8x16(a0, b0), self.mul_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn and_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.and_i8x16(a0, b0), self.and_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn or_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.or_i8x16(a0, b0), self.or_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.xor_i8x16(a0, b0), self.xor_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn not_i8x32(self, a: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        self.combine_i8x16(self.not_i8x16(a0), self.not_i8x16(a1))
-    }
-    #[inline(always)]
-    fn shl_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        self.combine_i8x16(self.shl_i8x16(a0, shift), self.shl_i8x16(a1, shift))
-    }
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.add_i8x16(a0, b0), self.add_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.sub_i8x16(a0, b0), self.sub_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.mul_i8x16(a0, b0), self.mul_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn and_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.and_i8x16(a0, b0), self.and_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn or_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.or_i8x16(a0, b0), self.or_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.xor_i8x16(a0, b0), self.xor_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn not_i8x32(self, a: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        self.combine_i8x16(self.not_i8x16(a0), self.not_i8x16(a1))
+    }
+    #[inline(always)]
+    fn shl_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        self.combine_i8x16(self.shl_i8x16(a0, shift), self.shl_i8x16(a1, shift))
+    }
     #[inline(always)]
     fn shlv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
         let (a0, a1) = self.split_i8x32(a);
@@ -7248,6 +8240,142 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -7729,35 +8857,171 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+    fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
-        let (a0, a1) = self.split_i16x16(a);
-        let (b0, b1) = self.split_i16x16(b);
-        self.combine_i16x8(self.add_i16x8(a0, b0), self.add_i16x8(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
-        let (a0, a1) = self.split_i16x16(a);
-        let (b0, b1) = self.split_i16x16(b);
-        self.combine_i16x8(self.sub_i16x8(a0, b0), self.sub_i16x8(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
-        let (a0, a1) = self.split_i16x16(a);
-        let (b0, b1) = self.split_i16x16(b);
-        self.combine_i16x8(self.mul_i16x8(a0, b0), self.mul_i16x8(a1, b1))
-    }
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
+        let (a0, a1) = self.split_i16x16(a);
+        let (b0, b1) = self.split_i16x16(b);
+        self.combine_i16x8(self.add_i16x8(a0, b0), self.add_i16x8(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
+        let (a0, a1) = self.split_i16x16(a);
+        let (b0, b1) = self.split_i16x16(b);
+        self.combine_i16x8(self.sub_i16x8(a0, b0), self.sub_i16x8(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
+        let (a0, a1) = self.split_i16x16(a);
+        let (b0, b1) = self.split_i16x16(b);
+        self.combine_i16x8(self.mul_i16x8(a0, b0), self.mul_i16x8(a1, b1))
+    }
     #[inline(always)]
     fn and_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
         let (a0, a1) = self.split_i16x16(a);
@@ -8091,6 +9355,142 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -8553,63 +9953,199 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+    fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.add_i32x4(a0, b0), self.add_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.sub_i32x4(a0, b0), self.sub_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.mul_i32x4(a0, b0), self.mul_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn and_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.and_i32x4(a0, b0), self.and_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn or_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.or_i32x4(a0, b0), self.or_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.xor_i32x4(a0, b0), self.xor_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn not_i32x8(self, a: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        self.combine_i32x4(self.not_i32x4(a0), self.not_i32x4(a1))
-    }
-    #[inline(always)]
-    fn shl_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        self.combine_i32x4(self.shl_i32x4(a0, shift), self.shl_i32x4(a1, shift))
-    }
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.add_i32x4(a0, b0), self.add_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.sub_i32x4(a0, b0), self.sub_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.mul_i32x4(a0, b0), self.mul_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn and_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.and_i32x4(a0, b0), self.and_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn or_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.or_i32x4(a0, b0), self.or_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.xor_i32x4(a0, b0), self.xor_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn not_i32x8(self, a: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        self.combine_i32x4(self.not_i32x4(a0), self.not_i32x4(a1))
+    }
+    #[inline(always)]
+    fn shl_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        self.combine_i32x4(self.shl_i32x4(a0, shift), self.shl_i32x4(a1, shift))
+    }
     #[inline(always)]
     fn shlv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
         let (a0, a1) = self.split_i32x8(a);
@@ -8884,6 +10420,142 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -9313,35 +10985,171 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+    fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn abs_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
-        let (a0, a1) = self.split_f64x4(a);
-        self.combine_f64x2(self.abs_f64x2(a0), self.abs_f64x2(a1))
-    }
-    #[inline(always)]
-    fn neg_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
-        let (a0, a1) = self.split_f64x4(a);
-        self.combine_f64x2(self.neg_f64x2(a0), self.neg_f64x2(a1))
-    }
-    #[inline(always)]
-    fn sqrt_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
-        let (a0, a1) = self.split_f64x4(a);
-        self.combine_f64x2(self.sqrt_f64x2(a0), self.sqrt_f64x2(a1))
-    }
-    #[inline(always)]
-    fn approximate_recip_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
-        let (a0, a1) = self.split_f64x4(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn abs_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
+        let (a0, a1) = self.split_f64x4(a);
+        self.combine_f64x2(self.abs_f64x2(a0), self.abs_f64x2(a1))
+    }
+    #[inline(always)]
+    fn neg_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
+        let (a0, a1) = self.split_f64x4(a);
+        self.combine_f64x2(self.neg_f64x2(a0), self.neg_f64x2(a1))
+    }
+    #[inline(always)]
+    fn sqrt_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
+        let (a0, a1) = self.split_f64x4(a);
+        self.combine_f64x2(self.sqrt_f64x2(a0), self.sqrt_f64x2(a1))
+    }
+    #[inline(always)]
+    fn approximate_recip_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
+        let (a0, a1) = self.split_f64x4(a);
         self.combine_f64x2(
             self.approximate_recip_f64x2(a0),
             self.approximate_recip_f64x2(a1),
@@ -9674,6 +11482,142 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -9984,63 +11928,199 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+    fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.add_u64x2(a0, b0), self.add_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.sub_u64x2(a0, b0), self.sub_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.mul_u64x2(a0, b0), self.mul_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn and_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.and_u64x2(a0, b0), self.and_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn or_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.or_u64x2(a0, b0), self.or_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.xor_u64x2(a0, b0), self.xor_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn not_u64x4(self, a: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        self.combine_u64x2(self.not_u64x2(a0), self.not_u64x2(a1))
-    }
-    #[inline(always)]
-    fn shl_u64x4(self, a: u64x4<Self>, shift: u32) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        self.combine_u64x2(self.shl_u64x2(a0, shift), self.shl_u64x2(a1, shift))
-    }
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.add_u64x2(a0, b0), self.add_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.sub_u64x2(a0, b0), self.sub_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.mul_u64x2(a0, b0), self.mul_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn and_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.and_u64x2(a0, b0), self.and_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn or_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.or_u64x2(a0, b0), self.or_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.xor_u64x2(a0, b0), self.xor_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn not_u64x4(self, a: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        self.combine_u64x2(self.not_u64x2(a0), self.not_u64x2(a1))
+    }
+    #[inline(always)]
+    fn shl_u64x4(self, a: u64x4<Self>, shift: u32) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        self.combine_u64x2(self.shl_u64x2(a0, shift), self.shl_u64x2(a1, shift))
+    }
     #[inline(always)]
     fn shlv_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
         let (a0, a1) = self.split_u64x4(a);
@@ -10460,121 +12540,385 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+    fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.abs_f32x8(a0), self.abs_f32x8(a1))
-    }
-    #[inline(always)]
-    fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.neg_f32x8(a0), self.neg_f32x8(a1))
-    }
-    #[inline(always)]
-    fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.sqrt_f32x8(a0), self.sqrt_f32x8(a1))
-    }
-    #[inline(always)]
-    fn approximate_recip_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(
-            self.approximate_recip_f32x8(a0),
-            self.approximate_recip_f32x8(a1),
-        )
-    }
-    #[inline(always)]
-    fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.add_f32x8(a0, b0), self.add_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.sub_f32x8(a0, b0), self.sub_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.mul_f32x8(a0, b0), self.mul_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.div_f32x8(a0, b0), self.div_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.copysign_f32x8(a0, b0), self.copysign_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_eq_f32x8(a0, b0), self.simd_eq_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_lt_f32x8(a0, b0), self.simd_lt_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_le_f32x8(a0, b0), self.simd_le_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_ge_f32x8(a0, b0), self.simd_ge_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_gt_f32x8(a0, b0), self.simd_gt_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, _) = self.split_f32x16(a);
-        let (b0, _) = self.split_f32x16(b);
-        self.combine_f32x8(self.zip_low_f32x8(a0, b0), self.zip_high_f32x8(a0, b0))
-    }
-    #[inline(always)]
-    fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (_, a1) = self.split_f32x16(a);
-        let (_, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.zip_low_f32x8(a1, b1), self.zip_high_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.unzip_low_f32x8(a0, a1), self.unzip_low_f32x8(b0, b1))
-    }
-    #[inline(always)]
-    fn unzip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.abs_f32x8(a0), self.abs_f32x8(a1))
+    }
+    #[inline(always)]
+    fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.neg_f32x8(a0), self.neg_f32x8(a1))
+    }
+    #[inline(always)]
+    fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.sqrt_f32x8(a0), self.sqrt_f32x8(a1))
+    }
+    #[inline(always)]
+    fn approximate_recip_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(
+            self.approximate_recip_f32x8(a0),
+            self.approximate_recip_f32x8(a1),
+        )
+    }
+    #[inline(always)]
+    fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.add_f32x8(a0, b0), self.add_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.sub_f32x8(a0, b0), self.sub_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.mul_f32x8(a0, b0), self.mul_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.div_f32x8(a0, b0), self.div_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.copysign_f32x8(a0, b0), self.copysign_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_eq_f32x8(a0, b0), self.simd_eq_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_lt_f32x8(a0, b0), self.simd_lt_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_le_f32x8(a0, b0), self.simd_le_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_ge_f32x8(a0, b0), self.simd_ge_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_gt_f32x8(a0, b0), self.simd_gt_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, _) = self.split_f32x16(a);
+        let (b0, _) = self.split_f32x16(b);
+        self.combine_f32x8(self.zip_low_f32x8(a0, b0), self.zip_high_f32x8(a0, b0))
+    }
+    #[inline(always)]
+    fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (_, a1) = self.split_f32x16(a);
+        let (_, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.zip_low_f32x8(a1, b1), self.zip_high_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.unzip_low_f32x8(a0, a1), self.unzip_low_f32x8(b0, b1))
+    }
+    #[inline(always)]
+    fn unzip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
         let (b0, b1) = self.split_f32x16(b);
         self.combine_f32x8(self.unzip_high_f32x8(a0, a1), self.unzip_high_f32x8(b0, b1))
     }
@@ -11110,6 +13454,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -11653,6 +14261,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -12264,6 +15136,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -12689,6 +15825,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -13213,6 +16613,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -13573,6 +17237,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -14034,6 +17962,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -14404,6 +18596,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -14723,6 +19179,270 @@ impl Simd for Fallback {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
diff --git a/fearless_simd/src/generated/neon.rs b/fearless_simd/src/generated/neon.rs
index 2006f700..2e4481a5 100644
--- a/fearless_simd/src/generated/neon.rs
+++ b/fearless_simd/src/generated/neon.rs
@@ -235,6 +235,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
+        self.swizzle_dyn_precise_f32x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -786,6 +790,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
+        self.swizzle_dyn_precise_i8x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -1246,6 +1254,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
+        self.swizzle_dyn_precise_u8x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -1863,6 +1875,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+        self.swizzle_dyn_precise_i16x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -2291,6 +2307,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
+        self.swizzle_dyn_precise_u16x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -2872,6 +2892,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
+        self.swizzle_dyn_precise_i32x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -3294,6 +3318,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
+        self.swizzle_dyn_precise_u32x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -3876,6 +3904,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
+        self.swizzle_dyn_precise_f64x2(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4343,6 +4375,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
+        self.swizzle_dyn_precise_i64x2(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4741,6 +4777,10 @@ impl Simd for Neon {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+        self.swizzle_dyn_precise_u64x2(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -5346,6 +5386,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
+        self.swizzle_dyn_precise_f32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -5887,6 +5931,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+        self.swizzle_dyn_precise_i8x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -6351,6 +6399,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
+        self.swizzle_dyn_precise_u8x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -6881,6 +6933,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+        self.swizzle_dyn_precise_i16x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -7285,6 +7341,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
+        self.swizzle_dyn_precise_u16x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -7787,6 +7847,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+        self.swizzle_dyn_precise_i32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -8160,6 +8224,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
+        self.swizzle_dyn_precise_u32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -8638,6 +8706,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+        self.swizzle_dyn_precise_f64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9041,6 +9113,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
+        self.swizzle_dyn_precise_i64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9393,6 +9469,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+        self.swizzle_dyn_precise_u64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9936,6 +10016,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+        self.swizzle_dyn_precise_f32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -10626,6 +10710,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
+        self.swizzle_dyn_precise_i8x64(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -11231,6 +11319,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
+        self.swizzle_dyn_precise_u8x64(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -11832,6 +11924,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
+        self.swizzle_dyn_precise_i16x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -12319,6 +12415,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
+        self.swizzle_dyn_precise_u16x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -12870,6 +12970,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
+        self.swizzle_dyn_precise_i32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -13292,6 +13396,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
+        self.swizzle_dyn_precise_u32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -13798,6 +13906,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
+        self.swizzle_dyn_precise_f64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -14230,6 +14342,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
+        self.swizzle_dyn_precise_i64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -14611,6 +14727,10 @@ impl Simd for Neon {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
+        self.swizzle_dyn_precise_u64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         crate::kernel!(
             #[inline(always)]
diff --git a/fearless_simd/src/generated/simd_trait.rs b/fearless_simd/src/generated/simd_trait.rs
index 6ce2f534..d9a9d2a1 100644
--- a/fearless_simd/src/generated/simd_trait.rs
+++ b/fearless_simd/src/generated/simd_trait.rs
@@ -201,6 +201,8 @@ pub trait Simd:
     ) -> f32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
     #[doc = "Compute the absolute value of each element."]
@@ -317,6 +319,8 @@ pub trait Simd:
     ) -> i8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -413,6 +417,8 @@ pub trait Simd:
     ) -> u8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -548,6 +554,8 @@ pub trait Simd:
     ) -> i16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -644,6 +652,8 @@ pub trait Simd:
     ) -> u16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -777,6 +787,8 @@ pub trait Simd:
     ) -> i32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -875,6 +887,8 @@ pub trait Simd:
     ) -> u32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -1010,6 +1024,8 @@ pub trait Simd:
     ) -> f64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
     #[doc = "Compute the absolute value of each element."]
@@ -1118,6 +1134,8 @@ pub trait Simd:
     ) -> i64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -1214,6 +1232,8 @@ pub trait Simd:
     ) -> u64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -1347,6 +1367,8 @@ pub trait Simd:
     ) -> f32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
     #[doc = "Compute the absolute value of each element."]
@@ -1465,6 +1487,8 @@ pub trait Simd:
     ) -> i8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -1563,6 +1587,8 @@ pub trait Simd:
     ) -> u8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -1706,6 +1732,8 @@ pub trait Simd:
         a: i16x16<Self>,
         indices: u8x32<Self>,
     ) -> i16x16<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -1808,6 +1836,8 @@ pub trait Simd:
         a: u16x16<Self>,
         indices: u8x32<Self>,
     ) -> u16x16<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -1947,6 +1977,8 @@ pub trait Simd:
     ) -> i32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -2047,6 +2079,8 @@ pub trait Simd:
     ) -> u32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -2186,6 +2220,8 @@ pub trait Simd:
     ) -> f64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
     #[doc = "Compute the absolute value of each element."]
@@ -2296,6 +2332,8 @@ pub trait Simd:
     ) -> i64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -2394,6 +2432,8 @@ pub trait Simd:
     ) -> u64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -2535,6 +2575,8 @@ pub trait Simd:
         a: f32x16<Self>,
         indices: u8x64<Self>,
     ) -> f32x16<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self>;
     #[doc = "Compute the absolute value of each element."]
@@ -2655,6 +2697,8 @@ pub trait Simd:
     ) -> i8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -2751,6 +2795,8 @@ pub trait Simd:
     ) -> u8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -2892,6 +2938,8 @@ pub trait Simd:
         a: i16x32<Self>,
         indices: u8x64<Self>,
     ) -> i16x32<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -2992,6 +3040,8 @@ pub trait Simd:
         a: u16x32<Self>,
         indices: u8x64<Self>,
     ) -> u16x32<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -3135,6 +3185,8 @@ pub trait Simd:
         a: i32x16<Self>,
         indices: u8x64<Self>,
     ) -> i32x16<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -3237,6 +3289,8 @@ pub trait Simd:
         a: u32x16<Self>,
         indices: u8x64<Self>,
     ) -> u32x16<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -3376,6 +3430,8 @@ pub trait Simd:
     ) -> f64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
     #[doc = "Compute the absolute value of each element."]
@@ -3484,6 +3540,8 @@ pub trait Simd:
     ) -> i64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -3580,6 +3638,8 @@ pub trait Simd:
     ) -> u64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
@@ -3811,6 +3871,8 @@ pub trait SimdBase<S: Simd>:
     fn shift_elements_right<const OFFSET: usize>(self, padding: Self::Element) -> Self;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
 }
diff --git a/fearless_simd/src/generated/simd_types.rs b/fearless_simd/src/generated/simd_types.rs
index ce9cc6a6..059a3805 100644
--- a/fearless_simd/src/generated/simd_types.rs
+++ b/fearless_simd/src/generated/simd_types.rs
@@ -160,6 +160,11 @@ impl<S: Simd> SimdBase<S> for f32x4<S> {
             .swizzle_dyn_within_blocks_f32x4(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_f32x4(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_f32x4(self, indices.simd_into(self.simd))
@@ -464,6 +469,11 @@ impl<S: Simd> SimdBase<S> for i8x16<S> {
             .swizzle_dyn_within_blocks_i8x16(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i8x16(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i8x16(self, indices.simd_into(self.simd))
@@ -700,6 +710,11 @@ impl<S: Simd> SimdBase<S> for u8x16<S> {
             .swizzle_dyn_within_blocks_u8x16(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u8x16(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u8x16(self, indices.simd_into(self.simd))
@@ -1019,6 +1034,11 @@ impl<S: Simd> SimdBase<S> for i16x8<S> {
             .swizzle_dyn_within_blocks_i16x8(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i16x8(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i16x8(self, indices.simd_into(self.simd))
@@ -1247,6 +1267,11 @@ impl<S: Simd> SimdBase<S> for u16x8<S> {
             .swizzle_dyn_within_blocks_u16x8(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u16x8(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u16x8(self, indices.simd_into(self.simd))
@@ -1557,6 +1582,11 @@ impl<S: Simd> SimdBase<S> for i32x4<S> {
             .swizzle_dyn_within_blocks_i32x4(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i32x4(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i32x4(self, indices.simd_into(self.simd))
@@ -1788,6 +1818,11 @@ impl<S: Simd> SimdBase<S> for u32x4<S> {
             .swizzle_dyn_within_blocks_u32x4(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u32x4(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u32x4(self, indices.simd_into(self.simd))
@@ -2110,6 +2145,11 @@ impl<S: Simd> SimdBase<S> for f64x2<S> {
             .swizzle_dyn_within_blocks_f64x2(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_f64x2(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_f64x2(self, indices.simd_into(self.simd))
@@ -2383,6 +2423,11 @@ impl<S: Simd> SimdBase<S> for i64x2<S> {
             .swizzle_dyn_within_blocks_i64x2(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i64x2(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i64x2(self, indices.simd_into(self.simd))
@@ -2602,6 +2647,11 @@ impl<S: Simd> SimdBase<S> for u64x2<S> {
             .swizzle_dyn_within_blocks_u64x2(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u64x2(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u64x2(self, indices.simd_into(self.simd))
@@ -2921,6 +2971,11 @@ impl<S: Simd> SimdBase<S> for f32x8<S> {
             .swizzle_dyn_within_blocks_f32x8(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_f32x8(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_f32x8(self, indices.simd_into(self.simd))
@@ -3248,6 +3303,11 @@ impl<S: Simd> SimdBase<S> for i8x32<S> {
             .swizzle_dyn_within_blocks_i8x32(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i8x32(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i8x32(self, indices.simd_into(self.simd))
@@ -3507,6 +3567,11 @@ impl<S: Simd> SimdBase<S> for u8x32<S> {
             .swizzle_dyn_within_blocks_u8x32(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u8x32(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u8x32(self, indices.simd_into(self.simd))
@@ -3847,6 +3912,11 @@ impl<S: Simd> SimdBase<S> for i16x16<S> {
             .swizzle_dyn_within_blocks_i16x16(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i16x16(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i16x16(self, indices.simd_into(self.simd))
@@ -4097,6 +4167,11 @@ impl<S: Simd> SimdBase<S> for u16x16<S> {
             .swizzle_dyn_within_blocks_u16x16(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u16x16(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u16x16(self, indices.simd_into(self.simd))
@@ -4424,6 +4499,11 @@ impl<S: Simd> SimdBase<S> for i32x8<S> {
             .swizzle_dyn_within_blocks_i32x8(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i32x8(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i32x8(self, indices.simd_into(self.simd))
@@ -4671,6 +4751,11 @@ impl<S: Simd> SimdBase<S> for u32x8<S> {
             .swizzle_dyn_within_blocks_u32x8(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u32x8(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u32x8(self, indices.simd_into(self.simd))
@@ -5000,6 +5085,11 @@ impl<S: Simd> SimdBase<S> for f64x4<S> {
             .swizzle_dyn_within_blocks_f64x4(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_f64x4(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_f64x4(self, indices.simd_into(self.simd))
@@ -5280,6 +5370,11 @@ impl<S: Simd> SimdBase<S> for i64x4<S> {
             .swizzle_dyn_within_blocks_i64x4(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i64x4(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i64x4(self, indices.simd_into(self.simd))
@@ -5506,6 +5601,11 @@ impl<S: Simd> SimdBase<S> for u64x4<S> {
             .swizzle_dyn_within_blocks_u64x4(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u64x4(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u64x4(self, indices.simd_into(self.simd))
@@ -5847,6 +5947,11 @@ impl<S: Simd> SimdBase<S> for f32x16<S> {
             .swizzle_dyn_within_blocks_f32x16(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_f32x16(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_f32x16(self, indices.simd_into(self.simd))
@@ -6201,6 +6306,11 @@ impl<S: Simd> SimdBase<S> for i8x64<S> {
             .swizzle_dyn_within_blocks_i8x64(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i8x64(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i8x64(self, indices.simd_into(self.simd))
@@ -6486,6 +6596,11 @@ impl<S: Simd> SimdBase<S> for u8x64<S> {
             .swizzle_dyn_within_blocks_u8x64(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u8x64(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u8x64(self, indices.simd_into(self.simd))
@@ -6836,6 +6951,11 @@ impl<S: Simd> SimdBase<S> for i16x32<S> {
             .swizzle_dyn_within_blocks_i16x32(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i16x32(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i16x32(self, indices.simd_into(self.simd))
@@ -7096,6 +7216,11 @@ impl<S: Simd> SimdBase<S> for u16x32<S> {
             .swizzle_dyn_within_blocks_u16x32(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u16x32(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u16x32(self, indices.simd_into(self.simd))
@@ -7431,6 +7556,11 @@ impl<S: Simd> SimdBase<S> for i32x16<S> {
             .swizzle_dyn_within_blocks_i32x16(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i32x16(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i32x16(self, indices.simd_into(self.simd))
@@ -7687,6 +7817,11 @@ impl<S: Simd> SimdBase<S> for u32x16<S> {
             .swizzle_dyn_within_blocks_u32x16(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u32x16(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u32x16(self, indices.simd_into(self.simd))
@@ -8020,6 +8155,11 @@ impl<S: Simd> SimdBase<S> for f64x8<S> {
             .swizzle_dyn_within_blocks_f64x8(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_f64x8(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_f64x8(self, indices.simd_into(self.simd))
@@ -8303,6 +8443,11 @@ impl<S: Simd> SimdBase<S> for i64x8<S> {
             .swizzle_dyn_within_blocks_i64x8(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_i64x8(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_i64x8(self, indices.simd_into(self.simd))
@@ -8532,6 +8677,11 @@ impl<S: Simd> SimdBase<S> for u64x8<S> {
             .swizzle_dyn_within_blocks_u64x8(self, indices.simd_into(self.simd))
     }
     #[inline(always)]
+    fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+        self.simd
+            .swizzle_dyn_u64x8(self, indices.simd_into(self.simd))
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
         self.simd
             .swizzle_dyn_precise_u64x8(self, indices.simd_into(self.simd))
diff --git a/fearless_simd/src/generated/sse2.rs b/fearless_simd/src/generated/sse2.rs
index f3ccd3d9..891171cd 100644
--- a/fearless_simd/src/generated/sse2.rs
+++ b/fearless_simd/src/generated/sse2.rs
@@ -365,6 +365,78 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -977,6 +1049,78 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -1548,6 +1692,78 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -2281,50 +2497,122 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+    fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 16usize];
-        for lane in 0..16usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 16usize];
-            output[lane] = if index < 16usize { value } else { 0 };
-        }
-        let result: u8x16<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
-        crate::kernel!(
-            #[inline(always)]
-            fn kernel(token: Sse2, a: i16x8<Sse2>, b: i16x8<Sse2>) -> i16x8<Sse2> {
-                _mm_add_epi16(a.into(), b.into()).simd_into(token)
-            }
-        );
-        kernel(self, a, b)
-    }
-    #[inline(always)]
-    fn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
-        crate::kernel!(
-            #[inline(always)]
-            fn kernel(token: Sse2, a: i16x8<Sse2>, b: i16x8<Sse2>) -> i16x8<Sse2> {
-                _mm_sub_epi16(a.into(), b.into()).simd_into(token)
-            }
-        );
-        kernel(self, a, b)
-    }
-    #[inline(always)]
-    fn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
-        crate::kernel!(
-            #[inline(always)]
-            fn kernel(token: Sse2, a: i16x8<Sse2>, b: i16x8<Sse2>) -> i16x8<Sse2> {
-                _mm_mullo_epi16(a.into(), b.into()).simd_into(token)
-            }
-        );
-        kernel(self, a, b)
-    }
-    #[inline(always)]
-    fn and_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
-        crate::kernel!(
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 16usize];
+            output[lane] = if index < 16usize { value } else { 0 };
+        }
+        let result: u8x16<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse2, a: i16x8<Sse2>, b: i16x8<Sse2>) -> i16x8<Sse2> {
+                _mm_add_epi16(a.into(), b.into()).simd_into(token)
+            }
+        );
+        kernel(self, a, b)
+    }
+    #[inline(always)]
+    fn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse2, a: i16x8<Sse2>, b: i16x8<Sse2>) -> i16x8<Sse2> {
+                _mm_sub_epi16(a.into(), b.into()).simd_into(token)
+            }
+        );
+        kernel(self, a, b)
+    }
+    #[inline(always)]
+    fn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse2, a: i16x8<Sse2>, b: i16x8<Sse2>) -> i16x8<Sse2> {
+                _mm_mullo_epi16(a.into(), b.into()).simd_into(token)
+            }
+        );
+        kernel(self, a, b)
+    }
+    #[inline(always)]
+    fn and_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
+        crate::kernel!(
             #[inline(always)]
             fn kernel(token: Sse2, a: i16x8<Sse2>, b: i16x8<Sse2>) -> i16x8<Sse2> {
                 _mm_and_si128(a.into(), b.into()).simd_into(token)
@@ -2765,6 +3053,78 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -3449,6 +3809,78 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -3941,6 +4373,78 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -4626,6 +5130,78 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -5116,6 +5692,78 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 16usize];
@@ -5551,50 +6199,122 @@ impl Simd for Sse2 {
         Bytes::from_bytes(result)
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+    fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 16usize];
-        for lane in 0..16usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 16usize];
-            output[lane] = if index < 16usize { value } else { 0 };
-        }
-        let result: u8x16<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
-        crate::kernel!(
-            #[inline(always)]
-            fn kernel(token: Sse2, a: u64x2<Sse2>, b: u64x2<Sse2>) -> u64x2<Sse2> {
-                _mm_add_epi64(a.into(), b.into()).simd_into(token)
-            }
-        );
-        kernel(self, a, b)
-    }
-    #[inline(always)]
-    fn sub_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
-        crate::kernel!(
-            #[inline(always)]
-            fn kernel(token: Sse2, a: u64x2<Sse2>, b: u64x2<Sse2>) -> u64x2<Sse2> {
-                _mm_sub_epi64(a.into(), b.into()).simd_into(token)
-            }
-        );
-        kernel(self, a, b)
-    }
-    #[inline(always)]
-    fn mul_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
-        [
-            u64::wrapping_mul(a[0usize], b[0usize]),
-            u64::wrapping_mul(a[1usize], b[1usize]),
-        ]
-        .simd_into(self)
-    }
-    #[inline(always)]
-    fn and_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
-        crate::kernel!(
-            #[inline(always)]
-            fn kernel(token: Sse2, a: u64x2<Sse2>, b: u64x2<Sse2>) -> u64x2<Sse2> {
+        let result: u8x16<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 16usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 16usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 16usize];
+            output[lane] = if index < 16usize { value } else { 0 };
+        }
+        let result: u8x16<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse2, a: u64x2<Sse2>, b: u64x2<Sse2>) -> u64x2<Sse2> {
+                _mm_add_epi64(a.into(), b.into()).simd_into(token)
+            }
+        );
+        kernel(self, a, b)
+    }
+    #[inline(always)]
+    fn sub_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse2, a: u64x2<Sse2>, b: u64x2<Sse2>) -> u64x2<Sse2> {
+                _mm_sub_epi64(a.into(), b.into()).simd_into(token)
+            }
+        );
+        kernel(self, a, b)
+    }
+    #[inline(always)]
+    fn mul_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
+        [
+            u64::wrapping_mul(a[0usize], b[0usize]),
+            u64::wrapping_mul(a[1usize], b[1usize]),
+        ]
+        .simd_into(self)
+    }
+    #[inline(always)]
+    fn and_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse2, a: u64x2<Sse2>, b: u64x2<Sse2>) -> u64x2<Sse2> {
                 _mm_and_si128(a.into(), b.into()).simd_into(token)
             }
         );
@@ -6110,6 +6830,142 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -6623,63 +7479,199 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+    fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.add_i8x16(a0, b0), self.add_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.sub_i8x16(a0, b0), self.sub_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.mul_i8x16(a0, b0), self.mul_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn and_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.and_i8x16(a0, b0), self.and_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn or_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.or_i8x16(a0, b0), self.or_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        let (b0, b1) = self.split_i8x32(b);
-        self.combine_i8x16(self.xor_i8x16(a0, b0), self.xor_i8x16(a1, b1))
-    }
-    #[inline(always)]
-    fn not_i8x32(self, a: i8x32<Self>) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        self.combine_i8x16(self.not_i8x16(a0), self.not_i8x16(a1))
-    }
-    #[inline(always)]
-    fn shl_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self> {
-        let (a0, a1) = self.split_i8x32(a);
-        self.combine_i8x16(self.shl_i8x16(a0, shift), self.shl_i8x16(a1, shift))
-    }
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.add_i8x16(a0, b0), self.add_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.sub_i8x16(a0, b0), self.sub_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.mul_i8x16(a0, b0), self.mul_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn and_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.and_i8x16(a0, b0), self.and_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn or_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.or_i8x16(a0, b0), self.or_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        let (b0, b1) = self.split_i8x32(b);
+        self.combine_i8x16(self.xor_i8x16(a0, b0), self.xor_i8x16(a1, b1))
+    }
+    #[inline(always)]
+    fn not_i8x32(self, a: i8x32<Self>) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        self.combine_i8x16(self.not_i8x16(a0), self.not_i8x16(a1))
+    }
+    #[inline(always)]
+    fn shl_i8x32(self, a: i8x32<Self>, shift: u32) -> i8x32<Self> {
+        let (a0, a1) = self.split_i8x32(a);
+        self.combine_i8x16(self.shl_i8x16(a0, shift), self.shl_i8x16(a1, shift))
+    }
     #[inline(always)]
     fn shlv_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
         let (a0, a1) = self.split_i8x32(a);
@@ -7059,6 +8051,142 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -7559,35 +8687,171 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+    fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
-        let (a0, a1) = self.split_i16x16(a);
-        let (b0, b1) = self.split_i16x16(b);
-        self.combine_i16x8(self.add_i16x8(a0, b0), self.add_i16x8(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
-        let (a0, a1) = self.split_i16x16(a);
-        let (b0, b1) = self.split_i16x16(b);
-        self.combine_i16x8(self.sub_i16x8(a0, b0), self.sub_i16x8(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
-        let (a0, a1) = self.split_i16x16(a);
-        let (b0, b1) = self.split_i16x16(b);
-        self.combine_i16x8(self.mul_i16x8(a0, b0), self.mul_i16x8(a1, b1))
-    }
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
+        let (a0, a1) = self.split_i16x16(a);
+        let (b0, b1) = self.split_i16x16(b);
+        self.combine_i16x8(self.add_i16x8(a0, b0), self.add_i16x8(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
+        let (a0, a1) = self.split_i16x16(a);
+        let (b0, b1) = self.split_i16x16(b);
+        self.combine_i16x8(self.sub_i16x8(a0, b0), self.sub_i16x8(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
+        let (a0, a1) = self.split_i16x16(a);
+        let (b0, b1) = self.split_i16x16(b);
+        self.combine_i16x8(self.mul_i16x8(a0, b0), self.mul_i16x8(a1, b1))
+    }
     #[inline(always)]
     fn and_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
         let (a0, a1) = self.split_i16x16(a);
@@ -7935,6 +9199,142 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -8415,63 +9815,199 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+    fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.add_i32x4(a0, b0), self.add_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.sub_i32x4(a0, b0), self.sub_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.mul_i32x4(a0, b0), self.mul_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn and_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.and_i32x4(a0, b0), self.and_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn or_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.or_i32x4(a0, b0), self.or_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        let (b0, b1) = self.split_i32x8(b);
-        self.combine_i32x4(self.xor_i32x4(a0, b0), self.xor_i32x4(a1, b1))
-    }
-    #[inline(always)]
-    fn not_i32x8(self, a: i32x8<Self>) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        self.combine_i32x4(self.not_i32x4(a0), self.not_i32x4(a1))
-    }
-    #[inline(always)]
-    fn shl_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self> {
-        let (a0, a1) = self.split_i32x8(a);
-        self.combine_i32x4(self.shl_i32x4(a0, shift), self.shl_i32x4(a1, shift))
-    }
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.add_i32x4(a0, b0), self.add_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.sub_i32x4(a0, b0), self.sub_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.mul_i32x4(a0, b0), self.mul_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn and_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.and_i32x4(a0, b0), self.and_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn or_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.or_i32x4(a0, b0), self.or_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        let (b0, b1) = self.split_i32x8(b);
+        self.combine_i32x4(self.xor_i32x4(a0, b0), self.xor_i32x4(a1, b1))
+    }
+    #[inline(always)]
+    fn not_i32x8(self, a: i32x8<Self>) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        self.combine_i32x4(self.not_i32x4(a0), self.not_i32x4(a1))
+    }
+    #[inline(always)]
+    fn shl_i32x8(self, a: i32x8<Self>, shift: u32) -> i32x8<Self> {
+        let (a0, a1) = self.split_i32x8(a);
+        self.combine_i32x4(self.shl_i32x4(a0, shift), self.shl_i32x4(a1, shift))
+    }
     #[inline(always)]
     fn shlv_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
         let (a0, a1) = self.split_i32x8(a);
@@ -8760,6 +10296,142 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -9208,35 +10880,171 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+    fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn abs_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
-        let (a0, a1) = self.split_f64x4(a);
-        self.combine_f64x2(self.abs_f64x2(a0), self.abs_f64x2(a1))
-    }
-    #[inline(always)]
-    fn neg_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
-        let (a0, a1) = self.split_f64x4(a);
-        self.combine_f64x2(self.neg_f64x2(a0), self.neg_f64x2(a1))
-    }
-    #[inline(always)]
-    fn sqrt_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
-        let (a0, a1) = self.split_f64x4(a);
-        self.combine_f64x2(self.sqrt_f64x2(a0), self.sqrt_f64x2(a1))
-    }
-    #[inline(always)]
-    fn approximate_recip_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
-        let (a0, a1) = self.split_f64x4(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn abs_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
+        let (a0, a1) = self.split_f64x4(a);
+        self.combine_f64x2(self.abs_f64x2(a0), self.abs_f64x2(a1))
+    }
+    #[inline(always)]
+    fn neg_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
+        let (a0, a1) = self.split_f64x4(a);
+        self.combine_f64x2(self.neg_f64x2(a0), self.neg_f64x2(a1))
+    }
+    #[inline(always)]
+    fn sqrt_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
+        let (a0, a1) = self.split_f64x4(a);
+        self.combine_f64x2(self.sqrt_f64x2(a0), self.sqrt_f64x2(a1))
+    }
+    #[inline(always)]
+    fn approximate_recip_f64x4(self, a: f64x4<Self>) -> f64x4<Self> {
+        let (a0, a1) = self.split_f64x4(a);
         self.combine_f64x2(
             self.approximate_recip_f64x2(a0),
             self.approximate_recip_f64x2(a1),
@@ -9583,6 +11391,142 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 32usize];
@@ -9907,63 +11851,199 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+    fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 32usize];
-        for lane in 0..32usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 32usize];
-            output[lane] = if index < 32usize { value } else { 0 };
-        }
-        let result: u8x32<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.add_u64x2(a0, b0), self.add_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.sub_u64x2(a0, b0), self.sub_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.mul_u64x2(a0, b0), self.mul_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn and_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.and_u64x2(a0, b0), self.and_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn or_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.or_u64x2(a0, b0), self.or_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        let (b0, b1) = self.split_u64x4(b);
-        self.combine_u64x2(self.xor_u64x2(a0, b0), self.xor_u64x2(a1, b1))
-    }
-    #[inline(always)]
-    fn not_u64x4(self, a: u64x4<Self>) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        self.combine_u64x2(self.not_u64x2(a0), self.not_u64x2(a1))
-    }
-    #[inline(always)]
-    fn shl_u64x4(self, a: u64x4<Self>, shift: u32) -> u64x4<Self> {
-        let (a0, a1) = self.split_u64x4(a);
-        self.combine_u64x2(self.shl_u64x2(a0, shift), self.shl_u64x2(a1, shift))
-    }
+        let result: u8x32<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 32usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 32usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 32usize];
+            output[lane] = if index < 32usize { value } else { 0 };
+        }
+        let result: u8x32<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.add_u64x2(a0, b0), self.add_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.sub_u64x2(a0, b0), self.sub_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.mul_u64x2(a0, b0), self.mul_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn and_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.and_u64x2(a0, b0), self.and_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn or_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.or_u64x2(a0, b0), self.or_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        let (b0, b1) = self.split_u64x4(b);
+        self.combine_u64x2(self.xor_u64x2(a0, b0), self.xor_u64x2(a1, b1))
+    }
+    #[inline(always)]
+    fn not_u64x4(self, a: u64x4<Self>) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        self.combine_u64x2(self.not_u64x2(a0), self.not_u64x2(a1))
+    }
+    #[inline(always)]
+    fn shl_u64x4(self, a: u64x4<Self>, shift: u32) -> u64x4<Self> {
+        let (a0, a1) = self.split_u64x4(a);
+        self.combine_u64x2(self.shl_u64x2(a0, shift), self.shl_u64x2(a1, shift))
+    }
     #[inline(always)]
     fn shlv_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
         let (a0, a1) = self.split_u64x4(a);
@@ -10402,121 +12482,385 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+    fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.abs_f32x8(a0), self.abs_f32x8(a1))
-    }
-    #[inline(always)]
-    fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.neg_f32x8(a0), self.neg_f32x8(a1))
-    }
-    #[inline(always)]
-    fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.sqrt_f32x8(a0), self.sqrt_f32x8(a1))
-    }
-    #[inline(always)]
-    fn approximate_recip_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(
-            self.approximate_recip_f32x8(a0),
-            self.approximate_recip_f32x8(a1),
-        )
-    }
-    #[inline(always)]
-    fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.add_f32x8(a0, b0), self.add_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.sub_f32x8(a0, b0), self.sub_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.mul_f32x8(a0, b0), self.mul_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.div_f32x8(a0, b0), self.div_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.copysign_f32x8(a0, b0), self.copysign_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_eq_f32x8(a0, b0), self.simd_eq_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_lt_f32x8(a0, b0), self.simd_lt_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_le_f32x8(a0, b0), self.simd_le_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_ge_f32x8(a0, b0), self.simd_ge_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_gt_f32x8(a0, b0), self.simd_gt_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, _) = self.split_f32x16(a);
-        let (b0, _) = self.split_f32x16(b);
-        self.combine_f32x8(self.zip_low_f32x8(a0, b0), self.zip_high_f32x8(a0, b0))
-    }
-    #[inline(always)]
-    fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (_, a1) = self.split_f32x16(a);
-        let (_, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.zip_low_f32x8(a1, b1), self.zip_high_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.unzip_low_f32x8(a0, a1), self.unzip_low_f32x8(b0, b1))
-    }
-    #[inline(always)]
-    fn unzip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.abs_f32x8(a0), self.abs_f32x8(a1))
+    }
+    #[inline(always)]
+    fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.neg_f32x8(a0), self.neg_f32x8(a1))
+    }
+    #[inline(always)]
+    fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.sqrt_f32x8(a0), self.sqrt_f32x8(a1))
+    }
+    #[inline(always)]
+    fn approximate_recip_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(
+            self.approximate_recip_f32x8(a0),
+            self.approximate_recip_f32x8(a1),
+        )
+    }
+    #[inline(always)]
+    fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.add_f32x8(a0, b0), self.add_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.sub_f32x8(a0, b0), self.sub_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.mul_f32x8(a0, b0), self.mul_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.div_f32x8(a0, b0), self.div_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.copysign_f32x8(a0, b0), self.copysign_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_eq_f32x8(a0, b0), self.simd_eq_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_lt_f32x8(a0, b0), self.simd_lt_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_le_f32x8(a0, b0), self.simd_le_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_ge_f32x8(a0, b0), self.simd_ge_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_gt_f32x8(a0, b0), self.simd_gt_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, _) = self.split_f32x16(a);
+        let (b0, _) = self.split_f32x16(b);
+        self.combine_f32x8(self.zip_low_f32x8(a0, b0), self.zip_high_f32x8(a0, b0))
+    }
+    #[inline(always)]
+    fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (_, a1) = self.split_f32x16(a);
+        let (_, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.zip_low_f32x8(a1, b1), self.zip_high_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.unzip_low_f32x8(a0, a1), self.unzip_low_f32x8(b0, b1))
+    }
+    #[inline(always)]
+    fn unzip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
         let (b0, b1) = self.split_f32x16(b);
         self.combine_f32x8(self.unzip_high_f32x8(a0, a1), self.unzip_high_f32x8(b0, b1))
     }
@@ -11111,6 +13455,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -11668,6 +14276,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -12298,6 +15170,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -12737,6 +15873,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -13289,6 +16689,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -13663,6 +17327,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -14188,6 +18116,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -14572,6 +18764,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -14905,6 +19361,270 @@ impl Simd for Sse2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
diff --git a/fearless_simd/src/generated/sse4_2.rs b/fearless_simd/src/generated/sse4_2.rs
index 5d37d4d3..f167cd19 100644
--- a/fearless_simd/src/generated/sse4_2.rs
+++ b/fearless_simd/src/generated/sse4_2.rs
@@ -240,6 +240,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: f32x4<Sse4_2>, indices: u8x16<Sse4_2>) -> f32x4<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -825,6 +839,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: i8x16<Sse4_2>, indices: u8x16<Sse4_2>) -> i8x16<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -1328,6 +1356,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: u8x16<Sse4_2>, indices: u8x16<Sse4_2>) -> u8x16<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -1982,6 +2024,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: i16x8<Sse4_2>, indices: u8x16<Sse4_2>) -> i16x8<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -2414,6 +2470,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: u16x8<Sse4_2>, indices: u8x16<Sse4_2>) -> u16x8<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -3004,6 +3074,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: i32x4<Sse4_2>, indices: u8x16<Sse4_2>) -> i32x4<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -3420,6 +3504,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: u32x4<Sse4_2>, indices: u8x16<Sse4_2>) -> u32x4<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4008,6 +4106,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: f64x2<Sse4_2>, indices: u8x16<Sse4_2>) -> f64x2<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4454,6 +4566,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: i64x2<Sse4_2>, indices: u8x16<Sse4_2>) -> i64x2<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -4828,6 +4954,20 @@ impl Simd for Sse4_2 {
         kernel(self, a, indices)
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+        crate::kernel!(
+            #[inline(always)]
+            fn kernel(token: Sse4_2, a: u64x2<Sse4_2>, indices: u8x16<Sse4_2>) -> u64x2<Sse4_2> {
+                let result = _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                Bytes::from_bytes(u8x16 {
+                    val: crate::support::Aligned128(result),
+                    simd: token,
+                })
+            }
+        );
+        kernel(self, a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -5382,6 +5522,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
+        self.swizzle_dyn_precise_f32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -5910,6 +6054,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+        self.swizzle_dyn_precise_i8x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -6361,6 +6509,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
+        self.swizzle_dyn_precise_u8x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -6876,6 +7028,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+        self.swizzle_dyn_precise_i16x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -7267,6 +7423,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
+        self.swizzle_dyn_precise_u16x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -7762,6 +7922,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+        self.swizzle_dyn_precise_i32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -8122,6 +8286,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
+        self.swizzle_dyn_precise_u32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -8585,6 +8753,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+        self.swizzle_dyn_precise_f64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -8975,6 +9147,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
+        self.swizzle_dyn_precise_i64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9314,6 +9490,10 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+        self.swizzle_dyn_precise_u64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         crate::kernel!(
             #[inline(always)]
@@ -9824,113 +10004,377 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+    fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.abs_f32x8(a0), self.abs_f32x8(a1))
-    }
-    #[inline(always)]
-    fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.neg_f32x8(a0), self.neg_f32x8(a1))
-    }
-    #[inline(always)]
-    fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(self.sqrt_f32x8(a0), self.sqrt_f32x8(a1))
-    }
-    #[inline(always)]
-    fn approximate_recip_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        self.combine_f32x8(
-            self.approximate_recip_f32x8(a0),
-            self.approximate_recip_f32x8(a1),
-        )
-    }
-    #[inline(always)]
-    fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.add_f32x8(a0, b0), self.add_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.sub_f32x8(a0, b0), self.sub_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.mul_f32x8(a0, b0), self.mul_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.div_f32x8(a0, b0), self.div_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.copysign_f32x8(a0, b0), self.copysign_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_eq_f32x8(a0, b0), self.simd_eq_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_lt_f32x8(a0, b0), self.simd_lt_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_le_f32x8(a0, b0), self.simd_le_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_ge_f32x8(a0, b0), self.simd_ge_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_f32x16(a);
-        let (b0, b1) = self.split_f32x16(b);
-        self.combine_mask32x8(self.simd_gt_f32x8(a0, b0), self.simd_gt_f32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (a0, _) = self.split_f32x16(a);
-        let (b0, _) = self.split_f32x16(b);
-        self.combine_f32x8(self.zip_low_f32x8(a0, b0), self.zip_high_f32x8(a0, b0))
-    }
-    #[inline(always)]
-    fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
-        let (_, a1) = self.split_f32x16(a);
-        let (_, b1) = self.split_f32x16(b);
-        self.combine_f32x8(self.zip_low_f32x8(a1, b1), self.zip_high_f32x8(a1, b1))
-    }
-    #[inline(always)]
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.abs_f32x8(a0), self.abs_f32x8(a1))
+    }
+    #[inline(always)]
+    fn neg_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.neg_f32x8(a0), self.neg_f32x8(a1))
+    }
+    #[inline(always)]
+    fn sqrt_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(self.sqrt_f32x8(a0), self.sqrt_f32x8(a1))
+    }
+    #[inline(always)]
+    fn approximate_recip_f32x16(self, a: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        self.combine_f32x8(
+            self.approximate_recip_f32x8(a0),
+            self.approximate_recip_f32x8(a1),
+        )
+    }
+    #[inline(always)]
+    fn add_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.add_f32x8(a0, b0), self.add_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.sub_f32x8(a0, b0), self.sub_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.mul_f32x8(a0, b0), self.mul_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn div_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.div_f32x8(a0, b0), self.div_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn copysign_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.copysign_f32x8(a0, b0), self.copysign_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_eq_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_eq_f32x8(a0, b0), self.simd_eq_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_lt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_lt_f32x8(a0, b0), self.simd_lt_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_le_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_le_f32x8(a0, b0), self.simd_le_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_ge_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_ge_f32x8(a0, b0), self.simd_ge_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_gt_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_f32x16(a);
+        let (b0, b1) = self.split_f32x16(b);
+        self.combine_mask32x8(self.simd_gt_f32x8(a0, b0), self.simd_gt_f32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn zip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (a0, _) = self.split_f32x16(a);
+        let (b0, _) = self.split_f32x16(b);
+        self.combine_f32x8(self.zip_low_f32x8(a0, b0), self.zip_high_f32x8(a0, b0))
+    }
+    #[inline(always)]
+    fn zip_high_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
+        let (_, a1) = self.split_f32x16(a);
+        let (_, b1) = self.split_f32x16(b);
+        self.combine_f32x8(self.zip_low_f32x8(a1, b1), self.zip_high_f32x8(a1, b1))
+    }
+    #[inline(always)]
     fn unzip_low_f32x16(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
         let (a0, a1) = self.split_f32x16(a);
         let (b0, b1) = self.split_f32x16(b);
@@ -10533,24 +10977,288 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
+    fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self> {
-        let (a0, a1) = self.split_i8x64(a);
-        let (b0, b1) = self.split_i8x64(b);
-        self.combine_i8x32(self.add_i8x32(a0, b0), self.add_i8x32(a1, b1))
-    }
-    #[inline(always)]
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self> {
+        let (a0, a1) = self.split_i8x64(a);
+        let (b0, b1) = self.split_i8x64(b);
+        self.combine_i8x32(self.add_i8x32(a0, b0), self.add_i8x32(a1, b1))
+    }
+    #[inline(always)]
     fn sub_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self> {
         let (a0, a1) = self.split_i8x64(a);
         let (b0, b1) = self.split_i8x64(b);
@@ -11090,113 +11798,377 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
+    fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_u8x32(self.add_u8x32(a0, b0), self.add_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_u8x32(self.sub_u8x32(a0, b0), self.sub_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_u8x32(self.mul_u8x32(a0, b0), self.mul_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn and_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_u8x32(self.and_u8x32(a0, b0), self.and_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn or_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_u8x32(self.or_u8x32(a0, b0), self.or_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_u8x32(self.xor_u8x32(a0, b0), self.xor_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn not_u8x64(self, a: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        self.combine_u8x32(self.not_u8x32(a0), self.not_u8x32(a1))
-    }
-    #[inline(always)]
-    fn shl_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        self.combine_u8x32(self.shl_u8x32(a0, shift), self.shl_u8x32(a1, shift))
-    }
-    #[inline(always)]
-    fn shlv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_u8x32(self.shlv_u8x32(a0, b0), self.shlv_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn shr_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        self.combine_u8x32(self.shr_u8x32(a0, shift), self.shr_u8x32(a1, shift))
-    }
-    #[inline(always)]
-    fn shrv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_u8x32(self.shrv_u8x32(a0, b0), self.shrv_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_eq_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_mask8x32(self.simd_eq_u8x32(a0, b0), self.simd_eq_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_lt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_mask8x32(self.simd_lt_u8x32(a0, b0), self.simd_lt_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_le_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_mask8x32(self.simd_le_u8x32(a0, b0), self.simd_le_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_ge_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_mask8x32(self.simd_ge_u8x32(a0, b0), self.simd_ge_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_gt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
-        let (a0, a1) = self.split_u8x64(a);
-        let (b0, b1) = self.split_u8x64(b);
-        self.combine_mask8x32(self.simd_gt_u8x32(a0, b0), self.simd_gt_u8x32(a1, b1))
-    }
-    #[inline(always)]
-    fn zip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
-        let (a0, _) = self.split_u8x64(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_u8x32(self.add_u8x32(a0, b0), self.add_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_u8x32(self.sub_u8x32(a0, b0), self.sub_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_u8x32(self.mul_u8x32(a0, b0), self.mul_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn and_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_u8x32(self.and_u8x32(a0, b0), self.and_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn or_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_u8x32(self.or_u8x32(a0, b0), self.or_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_u8x32(self.xor_u8x32(a0, b0), self.xor_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn not_u8x64(self, a: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        self.combine_u8x32(self.not_u8x32(a0), self.not_u8x32(a1))
+    }
+    #[inline(always)]
+    fn shl_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        self.combine_u8x32(self.shl_u8x32(a0, shift), self.shl_u8x32(a1, shift))
+    }
+    #[inline(always)]
+    fn shlv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_u8x32(self.shlv_u8x32(a0, b0), self.shlv_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn shr_u8x64(self, a: u8x64<Self>, shift: u32) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        self.combine_u8x32(self.shr_u8x32(a0, shift), self.shr_u8x32(a1, shift))
+    }
+    #[inline(always)]
+    fn shrv_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_u8x32(self.shrv_u8x32(a0, b0), self.shrv_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_eq_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_mask8x32(self.simd_eq_u8x32(a0, b0), self.simd_eq_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_lt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_mask8x32(self.simd_lt_u8x32(a0, b0), self.simd_lt_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_le_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_mask8x32(self.simd_le_u8x32(a0, b0), self.simd_le_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_ge_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_mask8x32(self.simd_ge_u8x32(a0, b0), self.simd_ge_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_gt_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> mask8x64<Self> {
+        let (a0, a1) = self.split_u8x64(a);
+        let (b0, b1) = self.split_u8x64(b);
+        self.combine_mask8x32(self.simd_gt_u8x32(a0, b0), self.simd_gt_u8x32(a1, b1))
+    }
+    #[inline(always)]
+    fn zip_low_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
+        let (a0, _) = self.split_u8x64(a);
         let (b0, _) = self.split_u8x64(b);
         self.combine_u8x32(self.zip_low_u8x32(a0, b0), self.zip_high_u8x32(a0, b0))
     }
@@ -11761,24 +12733,288 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
+    fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self> {
-        let (a0, a1) = self.split_i16x32(a);
-        let (b0, b1) = self.split_i16x32(b);
-        self.combine_i16x16(self.add_i16x16(a0, b0), self.add_i16x16(a1, b1))
-    }
-    #[inline(always)]
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self> {
+        let (a0, a1) = self.split_i16x32(a);
+        let (b0, b1) = self.split_i16x32(b);
+        self.combine_i16x16(self.add_i16x16(a0, b0), self.add_i16x16(a1, b1))
+    }
+    #[inline(always)]
     fn sub_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self> {
         let (a0, a1) = self.split_i16x32(a);
         let (b0, b1) = self.split_i16x32(b);
@@ -12200,113 +13436,377 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
+    fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_u16x16(self.add_u16x16(a0, b0), self.add_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_u16x16(self.sub_u16x16(a0, b0), self.sub_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_u16x16(self.mul_u16x16(a0, b0), self.mul_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn and_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_u16x16(self.and_u16x16(a0, b0), self.and_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn or_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_u16x16(self.or_u16x16(a0, b0), self.or_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_u16x16(self.xor_u16x16(a0, b0), self.xor_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn not_u16x32(self, a: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        self.combine_u16x16(self.not_u16x16(a0), self.not_u16x16(a1))
-    }
-    #[inline(always)]
-    fn shl_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        self.combine_u16x16(self.shl_u16x16(a0, shift), self.shl_u16x16(a1, shift))
-    }
-    #[inline(always)]
-    fn shlv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_u16x16(self.shlv_u16x16(a0, b0), self.shlv_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn shr_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        self.combine_u16x16(self.shr_u16x16(a0, shift), self.shr_u16x16(a1, shift))
-    }
-    #[inline(always)]
-    fn shrv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_u16x16(self.shrv_u16x16(a0, b0), self.shrv_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_eq_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_mask16x16(self.simd_eq_u16x16(a0, b0), self.simd_eq_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_lt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_mask16x16(self.simd_lt_u16x16(a0, b0), self.simd_lt_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_le_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_mask16x16(self.simd_le_u16x16(a0, b0), self.simd_le_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_ge_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_mask16x16(self.simd_ge_u16x16(a0, b0), self.simd_ge_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_gt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
-        let (a0, a1) = self.split_u16x32(a);
-        let (b0, b1) = self.split_u16x32(b);
-        self.combine_mask16x16(self.simd_gt_u16x16(a0, b0), self.simd_gt_u16x16(a1, b1))
-    }
-    #[inline(always)]
-    fn zip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
-        let (a0, _) = self.split_u16x32(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_u16x16(self.add_u16x16(a0, b0), self.add_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_u16x16(self.sub_u16x16(a0, b0), self.sub_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_u16x16(self.mul_u16x16(a0, b0), self.mul_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn and_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_u16x16(self.and_u16x16(a0, b0), self.and_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn or_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_u16x16(self.or_u16x16(a0, b0), self.or_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_u16x16(self.xor_u16x16(a0, b0), self.xor_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn not_u16x32(self, a: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        self.combine_u16x16(self.not_u16x16(a0), self.not_u16x16(a1))
+    }
+    #[inline(always)]
+    fn shl_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        self.combine_u16x16(self.shl_u16x16(a0, shift), self.shl_u16x16(a1, shift))
+    }
+    #[inline(always)]
+    fn shlv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_u16x16(self.shlv_u16x16(a0, b0), self.shlv_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn shr_u16x32(self, a: u16x32<Self>, shift: u32) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        self.combine_u16x16(self.shr_u16x16(a0, shift), self.shr_u16x16(a1, shift))
+    }
+    #[inline(always)]
+    fn shrv_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_u16x16(self.shrv_u16x16(a0, b0), self.shrv_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_eq_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_mask16x16(self.simd_eq_u16x16(a0, b0), self.simd_eq_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_lt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_mask16x16(self.simd_lt_u16x16(a0, b0), self.simd_lt_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_le_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_mask16x16(self.simd_le_u16x16(a0, b0), self.simd_le_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_ge_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_mask16x16(self.simd_ge_u16x16(a0, b0), self.simd_ge_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_gt_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> mask16x32<Self> {
+        let (a0, a1) = self.split_u16x32(a);
+        let (b0, b1) = self.split_u16x32(b);
+        self.combine_mask16x16(self.simd_gt_u16x16(a0, b0), self.simd_gt_u16x16(a1, b1))
+    }
+    #[inline(always)]
+    fn zip_low_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
+        let (a0, _) = self.split_u16x32(a);
         let (b0, _) = self.split_u16x32(b);
         self.combine_u16x16(self.zip_low_u16x16(a0, b0), self.zip_high_u16x16(a0, b0))
     }
@@ -12789,24 +14289,288 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
+    fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self> {
-        let (a0, a1) = self.split_i32x16(a);
-        let (b0, b1) = self.split_i32x16(b);
-        self.combine_i32x8(self.add_i32x8(a0, b0), self.add_i32x8(a1, b1))
-    }
-    #[inline(always)]
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self> {
+        let (a0, a1) = self.split_i32x16(a);
+        let (b0, b1) = self.split_i32x16(b);
+        self.combine_i32x8(self.add_i32x8(a0, b0), self.add_i32x8(a1, b1))
+    }
+    #[inline(always)]
     fn sub_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self> {
         let (a0, a1) = self.split_i32x16(a);
         let (b0, b1) = self.split_i32x16(b);
@@ -13163,113 +14927,377 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
+    fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn add_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_u32x8(self.add_u32x8(a0, b0), self.add_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn sub_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_u32x8(self.sub_u32x8(a0, b0), self.sub_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn mul_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_u32x8(self.mul_u32x8(a0, b0), self.mul_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn and_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_u32x8(self.and_u32x8(a0, b0), self.and_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn or_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_u32x8(self.or_u32x8(a0, b0), self.or_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn xor_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_u32x8(self.xor_u32x8(a0, b0), self.xor_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn not_u32x16(self, a: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        self.combine_u32x8(self.not_u32x8(a0), self.not_u32x8(a1))
-    }
-    #[inline(always)]
-    fn shl_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        self.combine_u32x8(self.shl_u32x8(a0, shift), self.shl_u32x8(a1, shift))
-    }
-    #[inline(always)]
-    fn shlv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_u32x8(self.shlv_u32x8(a0, b0), self.shlv_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn shr_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        self.combine_u32x8(self.shr_u32x8(a0, shift), self.shr_u32x8(a1, shift))
-    }
-    #[inline(always)]
-    fn shrv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_u32x8(self.shrv_u32x8(a0, b0), self.shrv_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_eq_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_mask32x8(self.simd_eq_u32x8(a0, b0), self.simd_eq_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_lt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_mask32x8(self.simd_lt_u32x8(a0, b0), self.simd_lt_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_le_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_mask32x8(self.simd_le_u32x8(a0, b0), self.simd_le_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_ge_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_mask32x8(self.simd_ge_u32x8(a0, b0), self.simd_ge_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn simd_gt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
-        let (a0, a1) = self.split_u32x16(a);
-        let (b0, b1) = self.split_u32x16(b);
-        self.combine_mask32x8(self.simd_gt_u32x8(a0, b0), self.simd_gt_u32x8(a1, b1))
-    }
-    #[inline(always)]
-    fn zip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
-        let (a0, _) = self.split_u32x16(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn add_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_u32x8(self.add_u32x8(a0, b0), self.add_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn sub_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_u32x8(self.sub_u32x8(a0, b0), self.sub_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn mul_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_u32x8(self.mul_u32x8(a0, b0), self.mul_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn and_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_u32x8(self.and_u32x8(a0, b0), self.and_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn or_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_u32x8(self.or_u32x8(a0, b0), self.or_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn xor_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_u32x8(self.xor_u32x8(a0, b0), self.xor_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn not_u32x16(self, a: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        self.combine_u32x8(self.not_u32x8(a0), self.not_u32x8(a1))
+    }
+    #[inline(always)]
+    fn shl_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        self.combine_u32x8(self.shl_u32x8(a0, shift), self.shl_u32x8(a1, shift))
+    }
+    #[inline(always)]
+    fn shlv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_u32x8(self.shlv_u32x8(a0, b0), self.shlv_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn shr_u32x16(self, a: u32x16<Self>, shift: u32) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        self.combine_u32x8(self.shr_u32x8(a0, shift), self.shr_u32x8(a1, shift))
+    }
+    #[inline(always)]
+    fn shrv_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_u32x8(self.shrv_u32x8(a0, b0), self.shrv_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_eq_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_mask32x8(self.simd_eq_u32x8(a0, b0), self.simd_eq_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_lt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_mask32x8(self.simd_lt_u32x8(a0, b0), self.simd_lt_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_le_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_mask32x8(self.simd_le_u32x8(a0, b0), self.simd_le_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_ge_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_mask32x8(self.simd_ge_u32x8(a0, b0), self.simd_ge_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn simd_gt_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> mask32x16<Self> {
+        let (a0, a1) = self.split_u32x16(a);
+        let (b0, b1) = self.split_u32x16(b);
+        self.combine_mask32x8(self.simd_gt_u32x8(a0, b0), self.simd_gt_u32x8(a1, b1))
+    }
+    #[inline(always)]
+    fn zip_low_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
+        let (a0, _) = self.split_u32x16(a);
         let (b0, _) = self.split_u32x16(b);
         self.combine_u32x8(self.zip_low_u32x8(a0, b0), self.zip_high_u32x8(a0, b0))
     }
@@ -13688,24 +15716,288 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
-    fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
+    fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let mut output = [0u8; 64usize];
-        for lane in 0..64usize {
-            let index = indices[lane] as usize;
-            let value = bytes[index % 64usize];
-            output[lane] = if index < 64usize { value } else { 0 };
-        }
-        let result: u8x64<Self> = output.simd_into(self);
-        Bytes::from_bytes(result)
-    }
-    #[inline(always)]
-    fn abs_f64x8(self, a: f64x8<Self>) -> f64x8<Self> {
-        let (a0, a1) = self.split_f64x8(a);
-        self.combine_f64x4(self.abs_f64x4(a0), self.abs_f64x4(a1))
-    }
-    #[inline(always)]
-    fn neg_f64x8(self, a: f64x8<Self>) -> f64x8<Self> {
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            let value = bytes[index % 64usize];
+            output[lane] = if index < 64usize { value } else { 0 };
+        }
+        let result: u8x64<Self> = output.simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
+    fn abs_f64x8(self, a: f64x8<Self>) -> f64x8<Self> {
+        let (a0, a1) = self.split_f64x8(a);
+        self.combine_f64x4(self.abs_f64x4(a0), self.abs_f64x4(a1))
+    }
+    #[inline(always)]
+    fn neg_f64x8(self, a: f64x8<Self>) -> f64x8<Self> {
         let (a0, a1) = self.split_f64x8(a);
         self.combine_f64x4(self.neg_f64x4(a0), self.neg_f64x4(a1))
     }
@@ -14072,6 +16364,270 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -14405,6 +16961,270 @@ impl Simd for Sse4_2 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
+        let bytes = Bytes::to_bytes(a);
+        let result: u8x64<Self> = [
+            {
+                let index = indices[0usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[1usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[2usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[3usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[4usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[5usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[6usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[7usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[8usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[9usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[10usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[11usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[12usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[13usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[14usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[15usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[16usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[17usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[18usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[19usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[20usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[21usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[22usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[23usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[24usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[25usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[26usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[27usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[28usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[29usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[30usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[31usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[32usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[33usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[34usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[35usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[36usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[37usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[38usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[39usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[40usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[41usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[42usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[43usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[44usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[45usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[46usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[47usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[48usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[49usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[50usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[51usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[52usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[53usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[54usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[55usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[56usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[57usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[58usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[59usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[60usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[61usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[62usize] as usize;
+                bytes[index % 64usize]
+            },
+            {
+                let index = indices[63usize] as usize;
+                bytes[index % 64usize]
+            },
+        ]
+        .simd_into(self);
+        Bytes::from_bytes(result)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
diff --git a/fearless_simd/src/generated/wasm.rs b/fearless_simd/src/generated/wasm.rs
index b221dc9e..2c4af508 100644
--- a/fearless_simd/src/generated/wasm.rs
+++ b/fearless_simd/src/generated/wasm.rs
@@ -217,6 +217,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
+        self.swizzle_dyn_precise_f32x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -593,6 +597,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
+        self.swizzle_dyn_precise_i8x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -932,6 +940,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
+        self.swizzle_dyn_precise_u8x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -1344,6 +1356,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
+        self.swizzle_dyn_precise_i16x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -1623,6 +1639,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
+        self.swizzle_dyn_precise_u16x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -1979,6 +1999,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
+        self.swizzle_dyn_precise_i32x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -2238,6 +2262,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
+        self.swizzle_dyn_precise_u32x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -2582,6 +2610,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
+        self.swizzle_dyn_precise_f64x2(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -2876,6 +2908,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
+        self.swizzle_dyn_precise_i64x2(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -3127,6 +3163,10 @@ impl Simd for WasmSimd128 {
         })
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
+        self.swizzle_dyn_precise_u64x2(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         let result = u8x16_swizzle(Bytes::to_bytes(a).val.0, indices.into());
         Bytes::from_bytes(u8x16 {
@@ -3522,6 +3562,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
+        self.swizzle_dyn_precise_f32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -4036,6 +4080,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
+        self.swizzle_dyn_precise_i8x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -4473,6 +4521,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
+        self.swizzle_dyn_precise_u8x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -4977,6 +5029,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
+        self.swizzle_dyn_precise_i16x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -5357,6 +5413,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
+        self.swizzle_dyn_precise_u16x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -5829,6 +5889,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
+        self.swizzle_dyn_precise_i32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -6178,6 +6242,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
+        self.swizzle_dyn_precise_u32x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -6630,6 +6698,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
+        self.swizzle_dyn_precise_f64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -7009,6 +7081,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
+        self.swizzle_dyn_precise_i64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -7337,6 +7413,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
+        self.swizzle_dyn_precise_u64x4(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         let bytes = Bytes::to_bytes(a);
         let (table_low, table_high) = self.split_u8x32(bytes);
@@ -7836,6 +7916,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
+        self.swizzle_dyn_precise_f32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -8512,6 +8596,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
+        self.swizzle_dyn_precise_i8x64(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -9065,6 +9153,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
+        self.swizzle_dyn_precise_u8x64(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -9679,6 +9771,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
+        self.swizzle_dyn_precise_i16x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -10117,6 +10213,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
+        self.swizzle_dyn_precise_u16x32(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -10657,6 +10757,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
+        self.swizzle_dyn_precise_i32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -11030,6 +11134,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
+        self.swizzle_dyn_precise_u32x16(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -11525,6 +11633,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
+        self.swizzle_dyn_precise_f64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -11908,6 +12020,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
+        self.swizzle_dyn_precise_i64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
@@ -12240,6 +12356,10 @@ impl Simd for WasmSimd128 {
         )
     }
     #[inline(always)]
+    fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
+        self.swizzle_dyn_precise_u64x8(a, indices)
+    }
+    #[inline(always)]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         let bytes = Bytes::to_bytes(a);
         let mut output = [0u8; 64usize];
diff --git a/fearless_simd_gen/src/generic.rs b/fearless_simd_gen/src/generic.rs
index 89090a62..2e8f05bd 100644
--- a/fearless_simd_gen/src/generic.rs
+++ b/fearless_simd_gen/src/generic.rs
@@ -79,9 +79,10 @@ pub(crate) fn integer_lane_mask_splat_arg(vec_ty: &VecType) -> TokenStream {
     }
 }
 
-/// Implementation based on split/combine
+/// Generic operation implementations.
 ///
-/// Only suitable for lane-wise and block-wise operations
+/// Most operations are implemented using split/combine, while some forward to
+/// another operation with compatible semantics.
 pub(crate) fn generic_op(op: &Op, ty: &VecType) -> TokenStream {
     let split = generic_op_name("split", ty);
     let half = VecType::new(ty.scalar, ty.scalar_bits, ty.len / 2);
@@ -136,6 +137,14 @@ pub(crate) fn generic_op(op: &Op, ty: &VecType) -> TokenStream {
                 }
             }
         }
+        OpSig::SwizzleDyn => {
+            let precise = generic_op_name("swizzle_dyn_precise", ty);
+            quote! {
+                #method_sig {
+                    self.#precise(a, indices)
+                }
+            }
+        }
         OpSig::SwizzleDynPrecise => {
             panic!("whole-vector swizzles cannot be done via split/combine");
         }
diff --git a/fearless_simd_gen/src/mk_fallback.rs b/fearless_simd_gen/src/mk_fallback.rs
index 2609039c..9b6de2c6 100644
--- a/fearless_simd_gen/src/mk_fallback.rs
+++ b/fearless_simd_gen/src/mk_fallback.rs
@@ -142,6 +142,13 @@ impl Level for Fallback {
         }
     }
 
+    fn should_use_generic_op(&self, op: &Op, vec_ty: &VecType) -> bool {
+        if matches!(op.sig, OpSig::SwizzleDyn) {
+            return false;
+        }
+        op.sig.should_use_generic_op(vec_ty, self.native_width())
+    }
+
     fn make_method(&self, op: Op, vec_ty: &VecType) -> TokenStream {
         let Op { sig, method, .. } = op;
         let method_sig = op.simd_trait_method_sig(vec_ty);
@@ -440,6 +447,31 @@ impl Level for Fallback {
                     }
                 }
             }
+            OpSig::SwizzleDyn => {
+                let bytes_ty = vec_ty.bytes_ty();
+                let bytes_rust = bytes_ty.rust();
+                let byte_count = bytes_ty.len;
+                let items = make_list(
+                    (0..byte_count)
+                        .map(|idx| {
+                            quote! {
+                                {
+                                    let index = indices[#idx] as usize;
+                                    bytes[index % #byte_count]
+                                }
+                            }
+                        })
+                        .collect::<Vec<_>>(),
+                );
+
+                quote! {
+                    #method_sig {
+                        let bytes = Bytes::to_bytes(a);
+                        let result: #bytes_rust<Self> = #items.simd_into(self);
+                        Bytes::from_bytes(result)
+                    }
+                }
+            }
             OpSig::SwizzleDynPrecise => {
                 let bytes_ty = vec_ty.bytes_ty();
                 let bytes_rust = bytes_ty.rust();
diff --git a/fearless_simd_gen/src/mk_neon.rs b/fearless_simd_gen/src/mk_neon.rs
index 61c04a94..90290d2a 100644
--- a/fearless_simd_gen/src/mk_neon.rs
+++ b/fearless_simd_gen/src/mk_neon.rs
@@ -478,6 +478,9 @@ impl Level for Neon {
                     }
                 })
             }
+            OpSig::SwizzleDyn => {
+                unreachable!("relaxed swizzles use the generic precise forwarding implementation")
+            }
             OpSig::SwizzleDynPrecise => {
                 let bytes_ty = vec_ty.bytes_ty();
                 let bytes = bytes_ty.rust();
diff --git a/fearless_simd_gen/src/mk_simd_types.rs b/fearless_simd_gen/src/mk_simd_types.rs
index b313f790..c1bd4bad 100644
--- a/fearless_simd_gen/src/mk_simd_types.rs
+++ b/fearless_simd_gen/src/mk_simd_types.rs
@@ -440,6 +440,7 @@ fn simd_vec_impl(ty: &VecType) -> TokenStream {
     let shift_elements_left_op = generic_op_name("shift_elements_left", ty);
     let shift_elements_right_op = generic_op_name("shift_elements_right", ty);
     let swizzle_dyn_within_blocks_op = generic_op_name("swizzle_dyn_within_blocks", ty);
+    let swizzle_dyn_op = generic_op_name("swizzle_dyn", ty);
     let swizzle_dyn_precise_op = generic_op_name("swizzle_dyn_precise", ty);
     quote! {
         impl<S: Simd> SimdBase<S> for #name<S> {
@@ -525,6 +526,11 @@ fn simd_vec_impl(ty: &VecType) -> TokenStream {
                 self.simd.#swizzle_dyn_within_blocks_op(self, indices.simd_into(self.simd))
             }
 
+            #[inline(always)]
+            fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
+                self.simd.#swizzle_dyn_op(self, indices.simd_into(self.simd))
+            }
+
             #[inline(always)]
             fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self {
                 self.simd.#swizzle_dyn_precise_op(self, indices.simd_into(self.simd))
diff --git a/fearless_simd_gen/src/mk_wasm.rs b/fearless_simd_gen/src/mk_wasm.rs
index b709f66c..6692c649 100644
--- a/fearless_simd_gen/src/mk_wasm.rs
+++ b/fearless_simd_gen/src/mk_wasm.rs
@@ -518,6 +518,9 @@ impl Level for WasmSimd128 {
                     }
                 }
             }
+            OpSig::SwizzleDyn => {
+                unreachable!("relaxed swizzles use the generic precise forwarding implementation")
+            }
             OpSig::SwizzleDynPrecise => match vec_ty.n_bits() {
                 128 => {
                     let bytes_ty = vec_ty.bytes_ty();
diff --git a/fearless_simd_gen/src/mk_x86.rs b/fearless_simd_gen/src/mk_x86.rs
index 89297cec..32a86a85 100644
--- a/fearless_simd_gen/src/mk_x86.rs
+++ b/fearless_simd_gen/src/mk_x86.rs
@@ -252,6 +252,10 @@ impl Level for X86 {
     }
 
     fn should_use_generic_op(&self, op: &Op, vec_ty: &VecType) -> bool {
+        if matches!(op.sig, OpSig::SwizzleDyn) {
+            return false;
+        }
+
         if *self == Self::Avx512
             && matches!(
                 op.sig,
@@ -302,6 +306,7 @@ impl Level for X86 {
                 unreachable!("element moves use generic lowering")
             }
             OpSig::SwizzleDynWithinBlocks => self.handle_swizzle_dyn_within_blocks(op, vec_ty),
+            OpSig::SwizzleDyn => self.handle_swizzle_dyn(op, vec_ty),
             OpSig::SwizzleDynPrecise => self.handle_swizzle_dyn_precise(op, vec_ty),
             OpSig::Cvt {
                 target_ty,
@@ -2820,6 +2825,70 @@ impl X86 {
         })
     }
 
+    pub(crate) fn handle_swizzle_dyn(&self, op: Op, vec_ty: &VecType) -> TokenStream {
+        let bytes_ty = vec_ty.bytes_ty();
+        let bytes = bytes_ty.rust();
+        let wrapper = bytes_ty.aligned_wrapper();
+
+        if *self == Self::Sse2 || (*self == Self::Sse4_2 && vec_ty.n_bits() == 512) {
+            return fallback_method(op, vec_ty);
+        }
+
+        // Emulated double-native-width variants delegate to swizzle_dyn_precise
+        // because zeroes let us cheaply join the two halves, and on AVX2 zeroing is already very cheap
+        // through a clever trick: https://shnatsel.github.io/improving-std-simd-swizzle-dyn/#optimizing-avx2
+        if matches!(
+            (*self, vec_ty.n_bits()),
+            (Self::Sse4_2, 256) | (Self::Avx2, 512)
+        ) {
+            let method_sig = op.simd_trait_method_sig(vec_ty);
+            let precise = generic_op_name("swizzle_dyn_precise", vec_ty);
+            return quote! {
+                #method_sig {
+                    self.#precise(a, indices)
+                }
+            };
+        }
+
+        // lower into native ops for native-width vectors
+        self.kernel_method(op, vec_ty, |token| {
+            let body = match (*self, vec_ty.n_bits()) {
+                (Self::Sse4_2 | Self::Avx2, 128) => quote! {
+                    let result =
+                        _mm_shuffle_epi8(Bytes::to_bytes(a).val.0, indices.into());
+                },
+                (Self::Avx2, 256) => quote! {
+                    let bytes = Bytes::to_bytes(a).val.0;
+                    let indices = indices.into();
+                    let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
+                    let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+
+                    // Move index bit 4 into each byte's sign bit for VPBLENDVB.
+                    let select_high = _mm256_slli_epi16::<3>(indices);
+                    let from_low = _mm256_shuffle_epi8(lolo, indices);
+                    let from_high = _mm256_shuffle_epi8(hihi, indices);
+                    let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                },
+                (Self::Avx512, 128 | 256 | 512) => {
+                    let permute = intrinsic_ident("permutexvar", "epi8", vec_ty.n_bits());
+                    quote! {
+                        let result =
+                            #permute(indices.into(), Bytes::to_bytes(a).val.0);
+                    }
+                }
+                _ => unreachable!(),
+            };
+
+            quote! {
+                #body
+                Bytes::from_bytes(#bytes {
+                    val: #wrapper(result),
+                    simd: #token,
+                })
+            }
+        })
+    }
+
     pub(crate) fn handle_swizzle_dyn_precise(&self, op: Op, vec_ty: &VecType) -> TokenStream {
         let bytes_ty = vec_ty.bytes_ty();
         let bytes = bytes_ty.rust();
diff --git a/fearless_simd_gen/src/ops.rs b/fearless_simd_gen/src/ops.rs
index af3e37d5..23550d28 100644
--- a/fearless_simd_gen/src/ops.rs
+++ b/fearless_simd_gen/src/ops.rs
@@ -97,6 +97,9 @@ pub(crate) enum OpSig {
     /// dynamically swizzled within each 128-bit block.
     SwizzleDynWithinBlocks,
     /// Takes a vector and a same-width byte-index vector, and returns the original vector type with its bytes
+    /// dynamically swizzled across the whole vector. Out-of-range indices produce implementation-defined bytes.
+    SwizzleDyn,
+    /// Takes a vector and a same-width byte-index vector, and returns the original vector type with its bytes
     /// dynamically swizzled across the whole vector. Out-of-range indices produce zero bytes.
     SwizzleDynPrecise,
     /// Takes a single argument of the source vector type, and returns a vector type of the target scalar type and the
@@ -314,7 +317,7 @@ impl Op {
             OpSig::ElementRotate { .. } => (vec![vec.clone()], vec),
             OpSig::ElementShift { .. } => (vec![vec.clone(), splat_arg_ty(vec_ty)], vec),
             OpSig::Slide { .. } => (vec![vec.clone(), vec.clone()], vec),
-            OpSig::SwizzleDynWithinBlocks | OpSig::SwizzleDynPrecise => {
+            OpSig::SwizzleDynWithinBlocks | OpSig::SwizzleDyn | OpSig::SwizzleDynPrecise => {
                 let bytes_ty = vec_ty.bytes_ty().rust();
                 (vec![vec.clone(), quote! { #bytes_ty<#simd_ty> }], vec)
             }
@@ -429,7 +432,7 @@ impl Op {
                 let arg1 = &arg_names[1];
                 quote! { <const SHIFT: usize>(#arg0, #arg1: impl SimdInto<Self, S>) -> Self }
             }
-            OpSig::SwizzleDynWithinBlocks | OpSig::SwizzleDynPrecise => {
+            OpSig::SwizzleDynWithinBlocks | OpSig::SwizzleDyn | OpSig::SwizzleDynPrecise => {
                 let arg0 = &arg_names[0];
                 let arg1 = &arg_names[1];
                 quote! { (#arg0, #arg1: impl SimdInto<Self::Bytes, S>) -> Self }
@@ -630,6 +633,14 @@ const BASE_OPS: &[Op] = &[
         The `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\n\
         Out-of-range index behavior varies by platform.",
     ),
+    Op::new(
+        "swizzle_dyn",
+        OpKind::BaseTraitMethod,
+        OpSig::SwizzleDyn,
+        "Dynamically swizzle this vector's bytes across the whole vector.\n\n\
+        The `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\n\
+        Use [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero.",
+    ),
     Op::new(
         "swizzle_dyn_precise",
         OpKind::BaseTraitMethod,
@@ -1545,8 +1556,8 @@ impl CoreOpTrait {
 }
 
 impl OpSig {
-    /// Determine whether a given operation should defer to the generic split/combine implementation, for a given vector
-    /// type and the maximum native vector width.
+    /// Determine whether a given operation should defer to its generic implementation, for a given vector type and the
+    /// maximum native vector width.
     pub(crate) fn should_use_generic_op(&self, vec_ty: &VecType, native_width: usize) -> bool {
         // For widen/narrow operations, we care about the *target* type's width.
         if let Self::WidenNarrow { target_ty } = self
@@ -1555,7 +1566,10 @@ impl OpSig {
             return false;
         }
 
-        if matches!(self, Self::ElementRotate { .. } | Self::ElementShift { .. }) {
+        if matches!(
+            self,
+            Self::ElementRotate { .. } | Self::ElementShift { .. } | Self::SwizzleDyn
+        ) {
             return true;
         }
 
@@ -1608,7 +1622,9 @@ impl OpSig {
             | Self::MaskReduce { .. }
             | Self::MaskToBitmask
             | Self::AsArray { .. } => &["a"],
-            Self::SwizzleDynWithinBlocks | Self::SwizzleDynPrecise => &["a", "indices"],
+            Self::SwizzleDynWithinBlocks | Self::SwizzleDyn | Self::SwizzleDynPrecise => {
+                &["a", "indices"]
+            }
             Self::Binary
             | Self::Compare
             | Self::Combine { .. }
@@ -1640,7 +1656,9 @@ impl OpSig {
             | Self::WidenNarrow { .. }
             | Self::MaskReduce { .. }
             | Self::AsArray { .. } => &["self"],
-            Self::SwizzleDynWithinBlocks | Self::SwizzleDynPrecise => &["self", "indices"],
+            Self::SwizzleDynWithinBlocks | Self::SwizzleDyn | Self::SwizzleDynPrecise => {
+                &["self", "indices"]
+            }
             Self::Binary
             | Self::Compare
             | Self::Zip { .. }
@@ -1704,6 +1722,7 @@ impl OpSig {
             | Self::AsArray { .. }
             | Self::StoreArray
             | Self::SwizzleDynWithinBlocks
+            | Self::SwizzleDyn
             | Self::SwizzleDynPrecise
             | Self::Slide { .. } => return None,
         };
diff --git a/fearless_simd_tests/tests/harness/ops/mod.rs b/fearless_simd_tests/tests/harness/ops/mod.rs
index 46e7e432..761a221a 100644
--- a/fearless_simd_tests/tests/harness/ops/mod.rs
+++ b/fearless_simd_tests/tests/harness/ops/mod.rs
@@ -75,6 +75,7 @@ mod store_array;
 mod store_interleaved_128;
 mod store_slice;
 mod sub;
+mod swizzle_dyn;
 mod swizzle_dyn_precise;
 mod swizzle_dyn_within_blocks;
 mod to_bitmask;

From 17af3d0cea356f2314eb9154e572a185aa879113 Mon Sep 17 00:00:00 2001
From: "Sergey \"Shnatsel\" Davidoff" <shnatsel@gmail.com>
Date: Mon, 3 Aug 2026 01:27:45 +0100
Subject: [PATCH 2/8] Add tests for swizzle_dyn

---
 .../tests/harness/ops/swizzle_dyn.rs          | 95 +++++++++++++++++++
 1 file changed, 95 insertions(+)
 create mode 100644 fearless_simd_tests/tests/harness/ops/swizzle_dyn.rs

diff --git a/fearless_simd_tests/tests/harness/ops/swizzle_dyn.rs b/fearless_simd_tests/tests/harness/ops/swizzle_dyn.rs
new file mode 100644
index 00000000..405b4f05
--- /dev/null
+++ b/fearless_simd_tests/tests/harness/ops/swizzle_dyn.rs
@@ -0,0 +1,95 @@
+// Copyright 2026 the Fearless_SIMD Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use fearless_simd::*;
+use fearless_simd_dev_macros::simd_test;
+
+fn assert_swizzle_dyn<const N: usize>(bytes: [u8; N], indices: [u8; N], result: [u8; N]) {
+    for i in 0..N {
+        let index = indices[i] as usize;
+        if index < N {
+            assert_eq!(result[i], bytes[index], "output lane {i}, index {index}");
+        }
+    }
+}
+
+#[simd_test]
+fn swizzle_dyn_u8x16<S: Simd>(simd: S) {
+    let bytes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+    let indices = [15, 14, 0, 1, 16, 17, 31, 127, 128, 255, 8, 7, 6, 5, 4, 3];
+
+    let value = u8x16::simd_from(simd, bytes);
+    let index_vec = u8x16::simd_from(simd, indices);
+    let result = value.swizzle_dyn(index_vec);
+
+    assert_swizzle_dyn(bytes, indices, *result);
+}
+
+#[simd_test]
+fn swizzle_dyn_u8x32_crosses_blocks<S: Simd>(simd: S) {
+    let bytes: [u8; 32] = core::array::from_fn(|i| u8::try_from(i + 1).unwrap());
+    let indices = [
+        31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 0, 1, 2, 3, 4, 5, 6, 7, 32,
+        33, 127, 128, 255, 15, 16, 31,
+    ];
+
+    let value = u8x32::simd_from(simd, bytes);
+    let index_vec = u8x32::simd_from(simd, indices);
+    let result = value.swizzle_dyn(index_vec);
+
+    assert_swizzle_dyn(bytes, indices, *result);
+}
+
+#[simd_test]
+fn swizzle_dyn_u8x64_crosses_blocks<S: Simd>(simd: S) {
+    let bytes: [u8; 64] = core::array::from_fn(|i| u8::try_from(i + 1).unwrap());
+    let indices: [u8; 64] = core::array::from_fn(|i| {
+        if i % 7 == 0 {
+            u8::try_from(64 + i).unwrap()
+        } else {
+            u8::try_from((i * 17) % 64).unwrap()
+        }
+    });
+
+    let value = u8x64::simd_from(simd, bytes);
+    let index_vec = u8x64::simd_from(simd, indices);
+    let result = value.swizzle_dyn(index_vec);
+
+    assert_swizzle_dyn(bytes, indices, *result);
+}
+
+#[simd_test]
+fn swizzle_dyn_bitcast_f32x8<S: Simd>(simd: S) {
+    let bytes: [u8; 32] = core::array::from_fn(|i| u8::try_from(i * 3 + 1).unwrap());
+    let indices = [
+        16, 17, 18, 19, 0, 1, 2, 3, 31, 30, 29, 28, 32, 33, 128, 255, 4, 5, 6, 7, 20, 21, 22, 23,
+        27, 26, 25, 24, 15, 14, 13, 12,
+    ];
+
+    let byte_vec = u8x32::simd_from(simd, bytes);
+    let value: f32x8<S> = byte_vec.bitcast();
+    let index_vec = u8x32::simd_from(simd, indices);
+    let result_bytes: u8x32<S> = value.swizzle_dyn(index_vec).bitcast();
+
+    assert_swizzle_dyn(bytes, indices, *result_bytes);
+}
+
+#[simd_test]
+fn swizzle_dyn_generic_indices<S: Simd>(simd: S) {
+    #[inline(always)]
+    fn do_swizzle<S: Simd, V: SimdBase<S>>(value: V, indices: V::Bytes) -> V {
+        value.swizzle_dyn(indices)
+    }
+
+    let bytes: [u8; 32] = core::array::from_fn(|i| u8::try_from(i + 1).unwrap());
+    let indices = [
+        16, 17, 18, 19, 20, 21, 22, 23, 31, 30, 29, 28, 27, 26, 25, 24, 0, 1, 2, 3, 4, 5, 6, 7, 32,
+        64, 127, 128, 255, 8, 9, 10,
+    ];
+
+    let value = u8x32::simd_from(simd, bytes);
+    let index_vec = u8x32::simd_from(simd, indices);
+    let result = do_swizzle::<S, u8x32<S>>(value, index_vec);
+
+    assert_swizzle_dyn(bytes, indices, *result);
+}

From b7dd69eced2c5ab49bc3479857680b65d798c3db Mon Sep 17 00:00:00 2001
From: "Sergey \"Shnatsel\" Davidoff" <shnatsel@gmail.com>
Date: Tue, 4 Aug 2026 12:01:35 +0100
Subject: [PATCH 3/8] Do not unroll the swizzle_dyn fallback implementation

---
 fearless_simd/src/generated/fallback.rs | 4750 +----------------------
 fearless_simd/src/generated/sse2.rs     | 4750 +----------------------
 fearless_simd/src/generated/sse4_2.rs   | 2650 +------------
 fearless_simd_gen/src/mk_fallback.rs    |   19 +-
 4 files changed, 426 insertions(+), 11743 deletions(-)

diff --git a/fearless_simd/src/generated/fallback.rs b/fearless_simd/src/generated/fallback.rs
index 3c513d37..ae70e5eb 100644
--- a/fearless_simd/src/generated/fallback.rs
+++ b/fearless_simd/src/generated/fallback.rs
@@ -340,73 +340,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -974,73 +913,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -1833,73 +1711,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -3006,73 +2823,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -3634,73 +3390,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -4458,73 +4153,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -4972,73 +4606,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -5622,73 +5195,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -6078,73 +5590,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -6518,73 +5969,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -7049,137 +6439,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -7684,137 +6949,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -8242,137 +7382,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -8859,137 +7874,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -9357,137 +8247,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -9955,137 +8720,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -10422,137 +9062,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -10987,137 +9502,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -11484,137 +9874,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -11930,137 +10195,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -12542,265 +10682,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -13456,265 +11343,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -14263,265 +11897,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -15138,265 +12519,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -15827,265 +12955,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -16615,265 +13490,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -17239,265 +13861,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -17964,265 +14333,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -18598,265 +14714,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -19181,265 +15044,12 @@ impl Simd for Fallback {
     #[inline(always)]
     fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
diff --git a/fearless_simd/src/generated/sse2.rs b/fearless_simd/src/generated/sse2.rs
index 891171cd..c1f91f40 100644
--- a/fearless_simd/src/generated/sse2.rs
+++ b/fearless_simd/src/generated/sse2.rs
@@ -367,73 +367,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -1051,73 +990,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -1694,73 +1572,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -2499,73 +2316,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -3055,73 +2811,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -3811,73 +3506,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -4375,73 +4009,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -5132,73 +4705,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -5694,73 +5206,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -6201,73 +5652,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x16<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 16usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 16usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 16usize];
+        for lane in 0..16usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 16usize];
+        }
+        let result: u8x16<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -6832,137 +6222,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -7481,137 +6746,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -8053,137 +7193,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -8689,137 +7704,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -9201,137 +8091,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -9817,137 +8582,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -10298,137 +8938,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -10882,137 +9397,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -11393,137 +9783,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -11853,137 +10118,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x32<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 32usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 32usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 32usize];
+        for lane in 0..32usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 32usize];
+        }
+        let result: u8x32<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -12484,265 +10624,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -13457,265 +11344,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -14278,265 +11912,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -15172,265 +12553,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -15875,265 +13003,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -16691,265 +13566,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -17329,265 +13951,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -18118,265 +14487,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -18766,265 +14882,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -19363,265 +15226,12 @@ impl Simd for Sse2 {
     #[inline(always)]
     fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
diff --git a/fearless_simd/src/generated/sse4_2.rs b/fearless_simd/src/generated/sse4_2.rs
index f167cd19..6b712a06 100644
--- a/fearless_simd/src/generated/sse4_2.rs
+++ b/fearless_simd/src/generated/sse4_2.rs
@@ -10006,265 +10006,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -10979,265 +10726,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -11800,265 +11294,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -12735,265 +11976,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -13438,265 +12426,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -14291,265 +13026,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -14929,265 +13411,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -15718,265 +13947,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -16366,265 +14342,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
@@ -16963,265 +14686,12 @@ impl Simd for Sse4_2 {
     #[inline(always)]
     fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self> {
         let bytes = Bytes::to_bytes(a);
-        let result: u8x64<Self> = [
-            {
-                let index = indices[0usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[1usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[2usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[3usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[4usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[5usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[6usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[7usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[8usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[9usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[10usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[11usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[12usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[13usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[14usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[15usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[16usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[17usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[18usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[19usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[20usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[21usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[22usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[23usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[24usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[25usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[26usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[27usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[28usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[29usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[30usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[31usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[32usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[33usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[34usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[35usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[36usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[37usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[38usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[39usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[40usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[41usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[42usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[43usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[44usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[45usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[46usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[47usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[48usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[49usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[50usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[51usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[52usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[53usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[54usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[55usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[56usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[57usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[58usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[59usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[60usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[61usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[62usize] as usize;
-                bytes[index % 64usize]
-            },
-            {
-                let index = indices[63usize] as usize;
-                bytes[index % 64usize]
-            },
-        ]
-        .simd_into(self);
+        let mut output = [0u8; 64usize];
+        for lane in 0..64usize {
+            let index = indices[lane] as usize;
+            output[lane] = bytes[index % 64usize];
+        }
+        let result: u8x64<Self> = output.simd_into(self);
         Bytes::from_bytes(result)
     }
     #[inline(always)]
diff --git a/fearless_simd_gen/src/mk_fallback.rs b/fearless_simd_gen/src/mk_fallback.rs
index 9b6de2c6..d531fd79 100644
--- a/fearless_simd_gen/src/mk_fallback.rs
+++ b/fearless_simd_gen/src/mk_fallback.rs
@@ -451,23 +451,16 @@ impl Level for Fallback {
                 let bytes_ty = vec_ty.bytes_ty();
                 let bytes_rust = bytes_ty.rust();
                 let byte_count = bytes_ty.len;
-                let items = make_list(
-                    (0..byte_count)
-                        .map(|idx| {
-                            quote! {
-                                {
-                                    let index = indices[#idx] as usize;
-                                    bytes[index % #byte_count]
-                                }
-                            }
-                        })
-                        .collect::<Vec<_>>(),
-                );
 
                 quote! {
                     #method_sig {
                         let bytes = Bytes::to_bytes(a);
-                        let result: #bytes_rust<Self> = #items.simd_into(self);
+                        let mut output = [0u8; #byte_count];
+                        for lane in 0..#byte_count {
+                            let index = indices[lane] as usize;
+                            output[lane] = bytes[index % #byte_count];
+                        }
+                        let result: #bytes_rust<Self> = output.simd_into(self);
                         Bytes::from_bytes(result)
                     }
                 }

From 8cc5496b66c2b6bcc2fb19ef028c1c58e2983772 Mon Sep 17 00:00:00 2001
From: "Sergey \"Shnatsel\" Davidoff" <shnatsel@gmail.com>
Date: Tue, 4 Aug 2026 12:08:21 +0100
Subject: [PATCH 4/8] Documentation wording

---
 fearless_simd/src/generated/simd_trait.rs | 62 +++++++++++------------
 fearless_simd_gen/src/ops.rs              |  2 +-
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/fearless_simd/src/generated/simd_trait.rs b/fearless_simd/src/generated/simd_trait.rs
index d9a9d2a1..0076afc3 100644
--- a/fearless_simd/src/generated/simd_trait.rs
+++ b/fearless_simd/src/generated/simd_trait.rs
@@ -201,7 +201,7 @@ pub trait Simd:
     ) -> f32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
@@ -319,7 +319,7 @@ pub trait Simd:
     ) -> i8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
@@ -417,7 +417,7 @@ pub trait Simd:
     ) -> u8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
@@ -554,7 +554,7 @@ pub trait Simd:
     ) -> i16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
@@ -652,7 +652,7 @@ pub trait Simd:
     ) -> u16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
@@ -787,7 +787,7 @@ pub trait Simd:
     ) -> i32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
@@ -887,7 +887,7 @@ pub trait Simd:
     ) -> u32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
@@ -1024,7 +1024,7 @@ pub trait Simd:
     ) -> f64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
@@ -1134,7 +1134,7 @@ pub trait Simd:
     ) -> i64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
@@ -1232,7 +1232,7 @@ pub trait Simd:
     ) -> u64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
@@ -1367,7 +1367,7 @@ pub trait Simd:
     ) -> f32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
@@ -1487,7 +1487,7 @@ pub trait Simd:
     ) -> i8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
@@ -1587,7 +1587,7 @@ pub trait Simd:
     ) -> u8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
@@ -1732,7 +1732,7 @@ pub trait Simd:
         a: i16x16<Self>,
         indices: u8x32<Self>,
     ) -> i16x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self>;
@@ -1836,7 +1836,7 @@ pub trait Simd:
         a: u16x16<Self>,
         indices: u8x32<Self>,
     ) -> u16x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self>;
@@ -1977,7 +1977,7 @@ pub trait Simd:
     ) -> i32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
@@ -2079,7 +2079,7 @@ pub trait Simd:
     ) -> u32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
@@ -2220,7 +2220,7 @@ pub trait Simd:
     ) -> f64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
@@ -2332,7 +2332,7 @@ pub trait Simd:
     ) -> i64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
@@ -2432,7 +2432,7 @@ pub trait Simd:
     ) -> u64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
@@ -2575,7 +2575,7 @@ pub trait Simd:
         a: f32x16<Self>,
         indices: u8x64<Self>,
     ) -> f32x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self>;
@@ -2697,7 +2697,7 @@ pub trait Simd:
     ) -> i8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
@@ -2795,7 +2795,7 @@ pub trait Simd:
     ) -> u8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
@@ -2938,7 +2938,7 @@ pub trait Simd:
         a: i16x32<Self>,
         indices: u8x64<Self>,
     ) -> i16x32<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self>;
@@ -3040,7 +3040,7 @@ pub trait Simd:
         a: u16x32<Self>,
         indices: u8x64<Self>,
     ) -> u16x32<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self>;
@@ -3185,7 +3185,7 @@ pub trait Simd:
         a: i32x16<Self>,
         indices: u8x64<Self>,
     ) -> i32x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self>;
@@ -3289,7 +3289,7 @@ pub trait Simd:
         a: u32x16<Self>,
         indices: u8x64<Self>,
     ) -> u32x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self>;
@@ -3430,7 +3430,7 @@ pub trait Simd:
     ) -> f64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
@@ -3540,7 +3540,7 @@ pub trait Simd:
     ) -> i64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
@@ -3638,7 +3638,7 @@ pub trait Simd:
     ) -> u64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
@@ -3871,7 +3871,7 @@ pub trait SimdBase<S: Simd>:
     fn shift_elements_right<const OFFSET: usize>(self, padding: Self::Element) -> Self;
     #[doc = "Dynamically swizzle this vector's bytes independently within each 128-bit block.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values `0..=15` select the corresponding byte from the same 128-bit input block.\n\nOut-of-range index behavior varies by platform."]
     fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
diff --git a/fearless_simd_gen/src/ops.rs b/fearless_simd_gen/src/ops.rs
index 23550d28..7930a31c 100644
--- a/fearless_simd_gen/src/ops.rs
+++ b/fearless_simd_gen/src/ops.rs
@@ -638,7 +638,7 @@ const BASE_OPS: &[Op] = &[
         OpKind::BaseTraitMethod,
         OpSig::SwizzleDyn,
         "Dynamically swizzle this vector's bytes across the whole vector.\n\n\
-        The `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values without undefined behavior.\n\n\
+        The `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\n\
         Use [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero.",
     ),
     Op::new(

From 23c5ad91a425cbd0d72a807c7b6904d74720ad1c Mon Sep 17 00:00:00 2001
From: "Sergey \"Shnatsel\" Davidoff" <shnatsel@gmail.com>
Date: Tue, 4 Aug 2026 12:10:37 +0100
Subject: [PATCH 5/8] More doc comment wording

---
 fearless_simd/src/generated/simd_trait.rs | 62 +++++++++++------------
 fearless_simd_gen/src/ops.rs              |  4 +-
 2 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/fearless_simd/src/generated/simd_trait.rs b/fearless_simd/src/generated/simd_trait.rs
index 0076afc3..3cad100e 100644
--- a/fearless_simd/src/generated/simd_trait.rs
+++ b/fearless_simd/src/generated/simd_trait.rs
@@ -203,7 +203,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_f32x4(self, a: f32x4<Self>, indices: u8x16<Self>) -> f32x4<Self>;
     #[doc = "Compute the absolute value of each element."]
     fn abs_f32x4(self, a: f32x4<Self>) -> f32x4<Self>;
@@ -321,7 +321,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i8x16(self, a: i8x16<Self>, indices: u8x16<Self>) -> i8x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self>;
@@ -419,7 +419,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self>;
@@ -556,7 +556,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i16x8(self, a: i16x8<Self>, indices: u8x16<Self>) -> i16x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self>;
@@ -654,7 +654,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u16x8(self, a: u16x8<Self>, indices: u8x16<Self>) -> u16x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self>;
@@ -789,7 +789,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i32x4(self, a: i32x4<Self>, indices: u8x16<Self>) -> i32x4<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self>;
@@ -889,7 +889,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u32x4(self, a: u32x4<Self>, indices: u8x16<Self>) -> u32x4<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self>;
@@ -1026,7 +1026,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_f64x2(self, a: f64x2<Self>, indices: u8x16<Self>) -> f64x2<Self>;
     #[doc = "Compute the absolute value of each element."]
     fn abs_f64x2(self, a: f64x2<Self>) -> f64x2<Self>;
@@ -1136,7 +1136,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i64x2(self, a: i64x2<Self>, indices: u8x16<Self>) -> i64x2<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self>;
@@ -1234,7 +1234,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u64x2(self, a: u64x2<Self>, indices: u8x16<Self>) -> u64x2<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self>;
@@ -1369,7 +1369,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_f32x8(self, a: f32x8<Self>, indices: u8x32<Self>) -> f32x8<Self>;
     #[doc = "Compute the absolute value of each element."]
     fn abs_f32x8(self, a: f32x8<Self>) -> f32x8<Self>;
@@ -1489,7 +1489,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i8x32(self, a: i8x32<Self>, indices: u8x32<Self>) -> i8x32<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self>;
@@ -1589,7 +1589,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self>;
@@ -1734,7 +1734,7 @@ pub trait Simd:
     ) -> i16x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i16x16(self, a: i16x16<Self>, indices: u8x32<Self>) -> i16x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self>;
@@ -1838,7 +1838,7 @@ pub trait Simd:
     ) -> u16x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u16x16(self, a: u16x16<Self>, indices: u8x32<Self>) -> u16x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self>;
@@ -1979,7 +1979,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i32x8(self, a: i32x8<Self>, indices: u8x32<Self>) -> i32x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self>;
@@ -2081,7 +2081,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u32x8(self, a: u32x8<Self>, indices: u8x32<Self>) -> u32x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self>;
@@ -2222,7 +2222,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_f64x4(self, a: f64x4<Self>, indices: u8x32<Self>) -> f64x4<Self>;
     #[doc = "Compute the absolute value of each element."]
     fn abs_f64x4(self, a: f64x4<Self>) -> f64x4<Self>;
@@ -2334,7 +2334,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i64x4(self, a: i64x4<Self>, indices: u8x32<Self>) -> i64x4<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self>;
@@ -2434,7 +2434,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u64x4(self, a: u64x4<Self>, indices: u8x32<Self>) -> u64x4<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self>;
@@ -2577,7 +2577,7 @@ pub trait Simd:
     ) -> f32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_f32x16(self, a: f32x16<Self>, indices: u8x64<Self>) -> f32x16<Self>;
     #[doc = "Compute the absolute value of each element."]
     fn abs_f32x16(self, a: f32x16<Self>) -> f32x16<Self>;
@@ -2699,7 +2699,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i8x64(self, a: i8x64<Self>, indices: u8x64<Self>) -> i8x64<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i8x64(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self>;
@@ -2797,7 +2797,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u8x64(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self>;
@@ -2940,7 +2940,7 @@ pub trait Simd:
     ) -> i16x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i16x32(self, a: i16x32<Self>, indices: u8x64<Self>) -> i16x32<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i16x32(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self>;
@@ -3042,7 +3042,7 @@ pub trait Simd:
     ) -> u16x32<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u16x32(self, a: u16x32<Self>, indices: u8x64<Self>) -> u16x32<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u16x32(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self>;
@@ -3187,7 +3187,7 @@ pub trait Simd:
     ) -> i32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i32x16(self, a: i32x16<Self>, indices: u8x64<Self>) -> i32x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i32x16(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self>;
@@ -3291,7 +3291,7 @@ pub trait Simd:
     ) -> u32x16<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u32x16(self, a: u32x16<Self>, indices: u8x64<Self>) -> u32x16<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u32x16(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self>;
@@ -3432,7 +3432,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_f64x8(self, a: f64x8<Self>, indices: u8x64<Self>) -> f64x8<Self>;
     #[doc = "Compute the absolute value of each element."]
     fn abs_f64x8(self, a: f64x8<Self>) -> f64x8<Self>;
@@ -3542,7 +3542,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_i64x8(self, a: i64x8<Self>, indices: u8x64<Self>) -> i64x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_i64x8(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self>;
@@ -3640,7 +3640,7 @@ pub trait Simd:
     fn swizzle_dyn_within_blocks_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise_u64x8(self, a: u64x8<Self>, indices: u8x64<Self>) -> u64x8<Self>;
     #[doc = "Add two vectors element-wise, wrapping on overflow."]
     fn add_u64x8(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self>;
@@ -3873,7 +3873,7 @@ pub trait SimdBase<S: Simd>:
     fn swizzle_dyn_within_blocks(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
     #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices safely produce implementation-defined byte values.\n\nUse [`SimdBase::swizzle_dyn_precise`] if out-of-range indices must produce zero."]
     fn swizzle_dyn(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
-    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes."]
+    #[doc = "Dynamically swizzle this vector's bytes across the whole vector.\n\nThe `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero."]
     fn swizzle_dyn_precise(self, indices: impl SimdInto<Self::Bytes, S>) -> Self;
 }
 #[doc = r" Functionality implemented by floating-point SIMD vectors."]
diff --git a/fearless_simd_gen/src/ops.rs b/fearless_simd_gen/src/ops.rs
index 7930a31c..db93279b 100644
--- a/fearless_simd_gen/src/ops.rs
+++ b/fearless_simd_gen/src/ops.rs
@@ -100,7 +100,7 @@ pub(crate) enum OpSig {
     /// dynamically swizzled across the whole vector. Out-of-range indices produce implementation-defined bytes.
     SwizzleDyn,
     /// Takes a vector and a same-width byte-index vector, and returns the original vector type with its bytes
-    /// dynamically swizzled across the whole vector. Out-of-range indices produce zero bytes.
+    /// dynamically swizzled across the whole vector. Out-of-range indices produce zero.
     SwizzleDynPrecise,
     /// Takes a single argument of the source vector type, and returns a vector type of the target scalar type and the
     /// same length.
@@ -646,7 +646,7 @@ const BASE_OPS: &[Op] = &[
         OpKind::BaseTraitMethod,
         OpSig::SwizzleDynPrecise,
         "Dynamically swizzle this vector's bytes across the whole vector.\n\n\
-        The `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero bytes.",
+        The `indices` operand is a same-width byte vector. For each output byte, index values within the vector's byte length select the corresponding byte from the input vector. Out-of-range indices produce zero.",
     ),
 ];
 

From 4159a7ca1d91146cfc3d25b7f5595237b8558f01 Mon Sep 17 00:00:00 2001
From: "Sergey \"Shnatsel\" Davidoff" <shnatsel@gmail.com>
Date: Tue, 4 Aug 2026 14:16:34 +0100
Subject: [PATCH 6/8] Optimize swizzle_dyn on AVX2: slightly better throughput,
 slightly worse latency, one less register

---
 fearless_simd/src/generated/avx2.rs | 130 +++++++++++++++-------------
 fearless_simd_gen/src/mk_x86.rs     |  18 ++--
 2 files changed, 82 insertions(+), 66 deletions(-)

diff --git a/fearless_simd/src/generated/avx2.rs b/fearless_simd/src/generated/avx2.rs
index d88a2977..64b83a3c 100644
--- a/fearless_simd/src/generated/avx2.rs
+++ b/fearless_simd/src/generated/avx2.rs
@@ -5623,12 +5623,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: f32x8<Avx2>, indices: u8x32<Avx2>) -> f32x8<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -6376,12 +6377,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: i8x32<Avx2>, indices: u8x32<Avx2>) -> i8x32<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -7088,12 +7090,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: u8x32<Avx2>, indices: u8x32<Avx2>) -> u8x32<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -7941,12 +7944,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: i16x16<Avx2>, indices: u8x32<Avx2>) -> i16x16<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -8544,12 +8548,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: u16x16<Avx2>, indices: u8x32<Avx2>) -> u16x16<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -9319,12 +9324,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: i32x8<Avx2>, indices: u8x32<Avx2>) -> i32x8<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -9846,12 +9852,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: u32x8<Avx2>, indices: u8x32<Avx2>) -> u32x8<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -10552,12 +10559,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: f64x4<Avx2>, indices: u8x32<Avx2>) -> f64x4<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -11102,12 +11110,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: i64x4<Avx2>, indices: u8x32<Avx2>) -> i64x4<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
@@ -11591,12 +11600,13 @@ impl Simd for Avx2 {
             fn kernel(token: Avx2, a: u64x4<Avx2>, indices: u8x32<Avx2>) -> u64x4<Avx2> {
                 let bytes = Bytes::to_bytes(a).val.0;
                 let indices = indices.into();
-                let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
-                let select_high = _mm256_slli_epi16::<3>(indices);
-                let from_low = _mm256_shuffle_epi8(lolo, indices);
-                let from_high = _mm256_shuffle_epi8(hihi, indices);
-                let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                let local = _mm256_shuffle_epi8(bytes, indices);
+                let remote = _mm256_shuffle_epi8(swapped, indices);
+                let select_remote = _mm256_slli_epi16::<3>(indices);
+                let flip_high_lane = _mm256_set_m128i(_mm_set1_epi8(i8::MIN), _mm_setzero_si128());
+                let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                let result = _mm256_blendv_epi8(local, remote, select_remote);
                 Bytes::from_bytes(u8x32 {
                     val: crate::support::Aligned256(result),
                     simd: token,
diff --git a/fearless_simd_gen/src/mk_x86.rs b/fearless_simd_gen/src/mk_x86.rs
index 32a86a85..6f6728f8 100644
--- a/fearless_simd_gen/src/mk_x86.rs
+++ b/fearless_simd_gen/src/mk_x86.rs
@@ -2860,14 +2860,20 @@ impl X86 {
                 (Self::Avx2, 256) => quote! {
                     let bytes = Bytes::to_bytes(a).val.0;
                     let indices = indices.into();
-                    let lolo = _mm256_permute2x128_si256::<0x00>(bytes, bytes);
-                    let hihi = _mm256_permute2x128_si256::<0x11>(bytes, bytes);
+                    let swapped = _mm256_permute2x128_si256::<0x01>(bytes, bytes);
+                    let local = _mm256_shuffle_epi8(bytes, indices);
+                    let remote = _mm256_shuffle_epi8(swapped, indices);
 
                     // Move index bit 4 into each byte's sign bit for VPBLENDVB.
-                    let select_high = _mm256_slli_epi16::<3>(indices);
-                    let from_low = _mm256_shuffle_epi8(lolo, indices);
-                    let from_high = _mm256_shuffle_epi8(hihi, indices);
-                    let result = _mm256_blendv_epi8(from_low, from_high, select_high);
+                    // The high output lane has the opposite local/remote mapping,
+                    // so invert its blend controls.
+                    let select_remote = _mm256_slli_epi16::<3>(indices);
+                    let flip_high_lane = _mm256_set_m128i(
+                        _mm_set1_epi8(i8::MIN),
+                        _mm_setzero_si128(),
+                    );
+                    let select_remote = _mm256_xor_si256(select_remote, flip_high_lane);
+                    let result = _mm256_blendv_epi8(local, remote, select_remote);
                 },
                 (Self::Avx512, 128 | 256 | 512) => {
                     let permute = intrinsic_ident("permutexvar", "epi8", vec_ty.n_bits());

From eacbc0a86c5112abff0b03d5951331dd2b51a1eb Mon Sep 17 00:00:00 2001
From: "Sergey \"Shnatsel\" Davidoff" <shnatsel@gmail.com>
Date: Tue, 4 Aug 2026 14:24:11 +0100
Subject: [PATCH 7/8] Add a random test for swizzle_dyn

---
 .../tests/harness/ops/swizzle_dyn.rs          | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/fearless_simd_tests/tests/harness/ops/swizzle_dyn.rs b/fearless_simd_tests/tests/harness/ops/swizzle_dyn.rs
index 405b4f05..5234152f 100644
--- a/fearless_simd_tests/tests/harness/ops/swizzle_dyn.rs
+++ b/fearless_simd_tests/tests/harness/ops/swizzle_dyn.rs
@@ -93,3 +93,57 @@ fn swizzle_dyn_generic_indices<S: Simd>(simd: S) {
 
     assert_swizzle_dyn(bytes, indices, *result);
 }
+
+#[simd_test]
+#[ignore = "this test is slow"]
+// run with: cargo test --release swizzle_dyn_random_u8_all_widths -- --ignored
+fn swizzle_dyn_random_u8_all_widths<S: Simd>(simd: S) {
+    let mut rng = fastrand::Rng::with_seed(0x5eed_5eed_cafe_f00d);
+
+    for iteration in 0..100_000 {
+        let mut bytes: [u8; 64] = [0; 64];
+        let mut indices: [u8; 64] = [0; 64];
+        rng.fill(&mut bytes);
+        rng.fill(&mut indices);
+
+        let bytes16 = &bytes[..16];
+        let indices16 = &indices[..16];
+        let value16 = u8x16::from_slice(simd, bytes16);
+        let index_vec16 = u8x16::from_slice(simd, indices16);
+        let result16 = value16.swizzle_dyn(index_vec16);
+        assert_random_swizzle_dyn_from_slice(bytes16, indices16, *result16, iteration);
+
+        let bytes32 = &bytes[..32];
+        let indices32 = &indices[..32];
+        let value32 = u8x32::from_slice(simd, bytes32);
+        let index_vec32 = u8x32::from_slice(simd, indices32);
+        let result32 = value32.swizzle_dyn(index_vec32);
+        assert_random_swizzle_dyn_from_slice(bytes32, indices32, *result32, iteration);
+
+        let bytes64 = &bytes[..64];
+        let indices64 = &indices[..64];
+        let value64 = u8x64::from_slice(simd, bytes64);
+        let index_vec64 = u8x64::from_slice(simd, indices64);
+        let result64 = value64.swizzle_dyn(index_vec64);
+        assert_random_swizzle_dyn_from_slice(bytes64, indices64, *result64, iteration);
+    }
+}
+
+fn assert_random_swizzle_dyn_from_slice<const N: usize>(
+    bytes: &[u8],
+    indices: &[u8],
+    result: [u8; N],
+    iteration: usize,
+) {
+    assert_eq!(bytes.len(), N);
+    assert_eq!(indices.len(), N);
+    for i in 0..N {
+        let index = indices[i] as usize;
+        if index < N {
+            assert_eq!(
+                result[i], bytes[index],
+                "iteration {iteration}, width {N}, output lane {i}, index {index}"
+            );
+        }
+    }
+}

From 151de207788b20c6dc39b518dc78da9a1b53e89f Mon Sep 17 00:00:00 2001
From: "Sergey \"Shnatsel\" Davidoff" <shnatsel@gmail.com>
Date: Tue, 4 Aug 2026 16:32:38 +0100
Subject: [PATCH 8/8] Clean up swizzle_dyn to swizzle_dyn_precise forwarding in
 the generator

---
 fearless_simd_gen/src/generic.rs     | 10 +---------
 fearless_simd_gen/src/mk_fallback.rs |  7 -------
 fearless_simd_gen/src/mk_neon.rs     |  7 ++++++-
 fearless_simd_gen/src/mk_wasm.rs     |  7 ++++++-
 fearless_simd_gen/src/mk_x86.rs      |  4 ----
 fearless_simd_gen/src/ops.rs         |  6 ++----
 6 files changed, 15 insertions(+), 26 deletions(-)

diff --git a/fearless_simd_gen/src/generic.rs b/fearless_simd_gen/src/generic.rs
index 2e8f05bd..9358a359 100644
--- a/fearless_simd_gen/src/generic.rs
+++ b/fearless_simd_gen/src/generic.rs
@@ -137,15 +137,7 @@ pub(crate) fn generic_op(op: &Op, ty: &VecType) -> TokenStream {
                 }
             }
         }
-        OpSig::SwizzleDyn => {
-            let precise = generic_op_name("swizzle_dyn_precise", ty);
-            quote! {
-                #method_sig {
-                    self.#precise(a, indices)
-                }
-            }
-        }
-        OpSig::SwizzleDynPrecise => {
+        OpSig::SwizzleDyn | OpSig::SwizzleDynPrecise => {
             panic!("whole-vector swizzles cannot be done via split/combine");
         }
         OpSig::Ternary => {
diff --git a/fearless_simd_gen/src/mk_fallback.rs b/fearless_simd_gen/src/mk_fallback.rs
index d531fd79..0fcd34ce 100644
--- a/fearless_simd_gen/src/mk_fallback.rs
+++ b/fearless_simd_gen/src/mk_fallback.rs
@@ -142,13 +142,6 @@ impl Level for Fallback {
         }
     }
 
-    fn should_use_generic_op(&self, op: &Op, vec_ty: &VecType) -> bool {
-        if matches!(op.sig, OpSig::SwizzleDyn) {
-            return false;
-        }
-        op.sig.should_use_generic_op(vec_ty, self.native_width())
-    }
-
     fn make_method(&self, op: Op, vec_ty: &VecType) -> TokenStream {
         let Op { sig, method, .. } = op;
         let method_sig = op.simd_trait_method_sig(vec_ty);
diff --git a/fearless_simd_gen/src/mk_neon.rs b/fearless_simd_gen/src/mk_neon.rs
index 90290d2a..5659539f 100644
--- a/fearless_simd_gen/src/mk_neon.rs
+++ b/fearless_simd_gen/src/mk_neon.rs
@@ -479,7 +479,12 @@ impl Level for Neon {
                 })
             }
             OpSig::SwizzleDyn => {
-                unreachable!("relaxed swizzles use the generic precise forwarding implementation")
+                let precise = generic_op_name("swizzle_dyn_precise", vec_ty);
+                quote! {
+                    #method_sig {
+                        self.#precise(a, indices)
+                    }
+                }
             }
             OpSig::SwizzleDynPrecise => {
                 let bytes_ty = vec_ty.bytes_ty();
diff --git a/fearless_simd_gen/src/mk_wasm.rs b/fearless_simd_gen/src/mk_wasm.rs
index 6692c649..43f7c1f6 100644
--- a/fearless_simd_gen/src/mk_wasm.rs
+++ b/fearless_simd_gen/src/mk_wasm.rs
@@ -519,7 +519,12 @@ impl Level for WasmSimd128 {
                 }
             }
             OpSig::SwizzleDyn => {
-                unreachable!("relaxed swizzles use the generic precise forwarding implementation")
+                let precise = generic_op_name("swizzle_dyn_precise", vec_ty);
+                quote! {
+                    #method_sig {
+                        self.#precise(a, indices)
+                    }
+                }
             }
             OpSig::SwizzleDynPrecise => match vec_ty.n_bits() {
                 128 => {
diff --git a/fearless_simd_gen/src/mk_x86.rs b/fearless_simd_gen/src/mk_x86.rs
index 6f6728f8..c2e6ed8e 100644
--- a/fearless_simd_gen/src/mk_x86.rs
+++ b/fearless_simd_gen/src/mk_x86.rs
@@ -252,10 +252,6 @@ impl Level for X86 {
     }
 
     fn should_use_generic_op(&self, op: &Op, vec_ty: &VecType) -> bool {
-        if matches!(op.sig, OpSig::SwizzleDyn) {
-            return false;
-        }
-
         if *self == Self::Avx512
             && matches!(
                 op.sig,
diff --git a/fearless_simd_gen/src/ops.rs b/fearless_simd_gen/src/ops.rs
index db93279b..4d6c86cc 100644
--- a/fearless_simd_gen/src/ops.rs
+++ b/fearless_simd_gen/src/ops.rs
@@ -1566,10 +1566,7 @@ impl OpSig {
             return false;
         }
 
-        if matches!(
-            self,
-            Self::ElementRotate { .. } | Self::ElementShift { .. } | Self::SwizzleDyn
-        ) {
+        if matches!(self, Self::ElementRotate { .. } | Self::ElementShift { .. }) {
             return true;
         }
 
@@ -1584,6 +1581,7 @@ impl OpSig {
                 | Self::AsArray { .. }
                 | Self::StoreArray
                 | Self::MaskSet
+                | Self::SwizzleDyn
                 | Self::SwizzleDynPrecise
                 | Self::Slide {
                     granularity: SlideGranularity::AcrossBlocks,