Skip to main content

fearless_simd/generated/
ops.rs

1// Copyright 2025 the Fearless_SIMD Authors
2// SPDX-License-Identifier: Apache-2.0 OR MIT
3
4// This file is autogenerated by fearless_simd_gen
5
6use crate::{Simd, SimdInto};
7use crate::{
8    f32x4, f32x8, f32x16, f64x2, f64x4, f64x8, i8x16, i8x32, i8x64, i16x8, i16x16, i16x32, i32x4,
9    i32x8, i32x16, mask8x16, mask8x32, mask8x64, mask16x8, mask16x16, mask16x32, mask32x4,
10    mask32x8, mask32x16, mask64x2, mask64x4, mask64x8, u8x16, u8x32, u8x64, u16x8, u16x16, u16x32,
11    u32x4, u32x8, u32x16,
12};
13impl<S: Simd> core::ops::Neg for f32x4<S> {
14    type Output = Self;
15    #[doc = "Negate each element of the vector."]
16    #[inline(always)]
17    fn neg(self) -> Self::Output {
18        self.simd.neg_f32x4(self)
19    }
20}
21impl<S: Simd> core::ops::Add for f32x4<S> {
22    type Output = Self;
23    #[doc = "Add two vectors element-wise."]
24    #[inline(always)]
25    fn add(self, rhs: Self) -> Self::Output {
26        self.simd.add_f32x4(self, rhs)
27    }
28}
29impl<S: Simd> core::ops::AddAssign for f32x4<S> {
30    #[doc = "Add two vectors element-wise."]
31    #[inline(always)]
32    fn add_assign(&mut self, rhs: Self) {
33        *self = self.simd.add_f32x4(*self, rhs);
34    }
35}
36impl<S: Simd> core::ops::Add<f32> for f32x4<S> {
37    type Output = Self;
38    #[inline(always)]
39    fn add(self, rhs: f32) -> Self::Output {
40        self.simd.add_f32x4(self, rhs.simd_into(self.simd))
41    }
42}
43impl<S: Simd> core::ops::AddAssign<f32> for f32x4<S> {
44    #[inline(always)]
45    fn add_assign(&mut self, rhs: f32) {
46        *self = self.simd.add_f32x4(*self, rhs.simd_into(self.simd));
47    }
48}
49impl<S: Simd> core::ops::Add<f32x4<S>> for f32 {
50    type Output = f32x4<S>;
51    #[inline(always)]
52    fn add(self, rhs: f32x4<S>) -> Self::Output {
53        rhs.simd.add_f32x4(self.simd_into(rhs.simd), rhs)
54    }
55}
56impl<S: Simd> core::ops::Sub for f32x4<S> {
57    type Output = Self;
58    #[doc = "Subtract two vectors element-wise."]
59    #[inline(always)]
60    fn sub(self, rhs: Self) -> Self::Output {
61        self.simd.sub_f32x4(self, rhs)
62    }
63}
64impl<S: Simd> core::ops::SubAssign for f32x4<S> {
65    #[doc = "Subtract two vectors element-wise."]
66    #[inline(always)]
67    fn sub_assign(&mut self, rhs: Self) {
68        *self = self.simd.sub_f32x4(*self, rhs);
69    }
70}
71impl<S: Simd> core::ops::Sub<f32> for f32x4<S> {
72    type Output = Self;
73    #[inline(always)]
74    fn sub(self, rhs: f32) -> Self::Output {
75        self.simd.sub_f32x4(self, rhs.simd_into(self.simd))
76    }
77}
78impl<S: Simd> core::ops::SubAssign<f32> for f32x4<S> {
79    #[inline(always)]
80    fn sub_assign(&mut self, rhs: f32) {
81        *self = self.simd.sub_f32x4(*self, rhs.simd_into(self.simd));
82    }
83}
84impl<S: Simd> core::ops::Sub<f32x4<S>> for f32 {
85    type Output = f32x4<S>;
86    #[inline(always)]
87    fn sub(self, rhs: f32x4<S>) -> Self::Output {
88        rhs.simd.sub_f32x4(self.simd_into(rhs.simd), rhs)
89    }
90}
91impl<S: Simd> core::ops::Mul for f32x4<S> {
92    type Output = Self;
93    #[doc = "Multiply two vectors element-wise."]
94    #[inline(always)]
95    fn mul(self, rhs: Self) -> Self::Output {
96        self.simd.mul_f32x4(self, rhs)
97    }
98}
99impl<S: Simd> core::ops::MulAssign for f32x4<S> {
100    #[doc = "Multiply two vectors element-wise."]
101    #[inline(always)]
102    fn mul_assign(&mut self, rhs: Self) {
103        *self = self.simd.mul_f32x4(*self, rhs);
104    }
105}
106impl<S: Simd> core::ops::Mul<f32> for f32x4<S> {
107    type Output = Self;
108    #[inline(always)]
109    fn mul(self, rhs: f32) -> Self::Output {
110        self.simd.mul_f32x4(self, rhs.simd_into(self.simd))
111    }
112}
113impl<S: Simd> core::ops::MulAssign<f32> for f32x4<S> {
114    #[inline(always)]
115    fn mul_assign(&mut self, rhs: f32) {
116        *self = self.simd.mul_f32x4(*self, rhs.simd_into(self.simd));
117    }
118}
119impl<S: Simd> core::ops::Mul<f32x4<S>> for f32 {
120    type Output = f32x4<S>;
121    #[inline(always)]
122    fn mul(self, rhs: f32x4<S>) -> Self::Output {
123        rhs.simd.mul_f32x4(self.simd_into(rhs.simd), rhs)
124    }
125}
126impl<S: Simd> core::ops::Div for f32x4<S> {
127    type Output = Self;
128    #[doc = "Divide two vectors element-wise."]
129    #[inline(always)]
130    fn div(self, rhs: Self) -> Self::Output {
131        self.simd.div_f32x4(self, rhs)
132    }
133}
134impl<S: Simd> core::ops::DivAssign for f32x4<S> {
135    #[doc = "Divide two vectors element-wise."]
136    #[inline(always)]
137    fn div_assign(&mut self, rhs: Self) {
138        *self = self.simd.div_f32x4(*self, rhs);
139    }
140}
141impl<S: Simd> core::ops::Div<f32> for f32x4<S> {
142    type Output = Self;
143    #[inline(always)]
144    fn div(self, rhs: f32) -> Self::Output {
145        self.simd.div_f32x4(self, rhs.simd_into(self.simd))
146    }
147}
148impl<S: Simd> core::ops::DivAssign<f32> for f32x4<S> {
149    #[inline(always)]
150    fn div_assign(&mut self, rhs: f32) {
151        *self = self.simd.div_f32x4(*self, rhs.simd_into(self.simd));
152    }
153}
154impl<S: Simd> core::ops::Div<f32x4<S>> for f32 {
155    type Output = f32x4<S>;
156    #[inline(always)]
157    fn div(self, rhs: f32x4<S>) -> Self::Output {
158        rhs.simd.div_f32x4(self.simd_into(rhs.simd), rhs)
159    }
160}
161impl<S: Simd> core::ops::Neg for i8x16<S> {
162    type Output = Self;
163    #[doc = "Negate each element of the vector, wrapping on overflow."]
164    #[inline(always)]
165    fn neg(self) -> Self::Output {
166        self.simd.neg_i8x16(self)
167    }
168}
169impl<S: Simd> core::ops::Add for i8x16<S> {
170    type Output = Self;
171    #[doc = "Add two vectors element-wise, wrapping on overflow."]
172    #[inline(always)]
173    fn add(self, rhs: Self) -> Self::Output {
174        self.simd.add_i8x16(self, rhs)
175    }
176}
177impl<S: Simd> core::ops::AddAssign for i8x16<S> {
178    #[doc = "Add two vectors element-wise, wrapping on overflow."]
179    #[inline(always)]
180    fn add_assign(&mut self, rhs: Self) {
181        *self = self.simd.add_i8x16(*self, rhs);
182    }
183}
184impl<S: Simd> core::ops::Add<i8> for i8x16<S> {
185    type Output = Self;
186    #[inline(always)]
187    fn add(self, rhs: i8) -> Self::Output {
188        self.simd.add_i8x16(self, rhs.simd_into(self.simd))
189    }
190}
191impl<S: Simd> core::ops::AddAssign<i8> for i8x16<S> {
192    #[inline(always)]
193    fn add_assign(&mut self, rhs: i8) {
194        *self = self.simd.add_i8x16(*self, rhs.simd_into(self.simd));
195    }
196}
197impl<S: Simd> core::ops::Add<i8x16<S>> for i8 {
198    type Output = i8x16<S>;
199    #[inline(always)]
200    fn add(self, rhs: i8x16<S>) -> Self::Output {
201        rhs.simd.add_i8x16(self.simd_into(rhs.simd), rhs)
202    }
203}
204impl<S: Simd> core::ops::Sub for i8x16<S> {
205    type Output = Self;
206    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
207    #[inline(always)]
208    fn sub(self, rhs: Self) -> Self::Output {
209        self.simd.sub_i8x16(self, rhs)
210    }
211}
212impl<S: Simd> core::ops::SubAssign for i8x16<S> {
213    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
214    #[inline(always)]
215    fn sub_assign(&mut self, rhs: Self) {
216        *self = self.simd.sub_i8x16(*self, rhs);
217    }
218}
219impl<S: Simd> core::ops::Sub<i8> for i8x16<S> {
220    type Output = Self;
221    #[inline(always)]
222    fn sub(self, rhs: i8) -> Self::Output {
223        self.simd.sub_i8x16(self, rhs.simd_into(self.simd))
224    }
225}
226impl<S: Simd> core::ops::SubAssign<i8> for i8x16<S> {
227    #[inline(always)]
228    fn sub_assign(&mut self, rhs: i8) {
229        *self = self.simd.sub_i8x16(*self, rhs.simd_into(self.simd));
230    }
231}
232impl<S: Simd> core::ops::Sub<i8x16<S>> for i8 {
233    type Output = i8x16<S>;
234    #[inline(always)]
235    fn sub(self, rhs: i8x16<S>) -> Self::Output {
236        rhs.simd.sub_i8x16(self.simd_into(rhs.simd), rhs)
237    }
238}
239impl<S: Simd> core::ops::Mul for i8x16<S> {
240    type Output = Self;
241    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
242    #[inline(always)]
243    fn mul(self, rhs: Self) -> Self::Output {
244        self.simd.mul_i8x16(self, rhs)
245    }
246}
247impl<S: Simd> core::ops::MulAssign for i8x16<S> {
248    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
249    #[inline(always)]
250    fn mul_assign(&mut self, rhs: Self) {
251        *self = self.simd.mul_i8x16(*self, rhs);
252    }
253}
254impl<S: Simd> core::ops::Mul<i8> for i8x16<S> {
255    type Output = Self;
256    #[inline(always)]
257    fn mul(self, rhs: i8) -> Self::Output {
258        self.simd.mul_i8x16(self, rhs.simd_into(self.simd))
259    }
260}
261impl<S: Simd> core::ops::MulAssign<i8> for i8x16<S> {
262    #[inline(always)]
263    fn mul_assign(&mut self, rhs: i8) {
264        *self = self.simd.mul_i8x16(*self, rhs.simd_into(self.simd));
265    }
266}
267impl<S: Simd> core::ops::Mul<i8x16<S>> for i8 {
268    type Output = i8x16<S>;
269    #[inline(always)]
270    fn mul(self, rhs: i8x16<S>) -> Self::Output {
271        rhs.simd.mul_i8x16(self.simd_into(rhs.simd), rhs)
272    }
273}
274impl<S: Simd> core::ops::BitAnd for i8x16<S> {
275    type Output = Self;
276    #[doc = "Compute the bitwise AND of two vectors."]
277    #[inline(always)]
278    fn bitand(self, rhs: Self) -> Self::Output {
279        self.simd.and_i8x16(self, rhs)
280    }
281}
282impl<S: Simd> core::ops::BitAndAssign for i8x16<S> {
283    #[doc = "Compute the bitwise AND of two vectors."]
284    #[inline(always)]
285    fn bitand_assign(&mut self, rhs: Self) {
286        *self = self.simd.and_i8x16(*self, rhs);
287    }
288}
289impl<S: Simd> core::ops::BitAnd<i8> for i8x16<S> {
290    type Output = Self;
291    #[inline(always)]
292    fn bitand(self, rhs: i8) -> Self::Output {
293        self.simd.and_i8x16(self, rhs.simd_into(self.simd))
294    }
295}
296impl<S: Simd> core::ops::BitAndAssign<i8> for i8x16<S> {
297    #[inline(always)]
298    fn bitand_assign(&mut self, rhs: i8) {
299        *self = self.simd.and_i8x16(*self, rhs.simd_into(self.simd));
300    }
301}
302impl<S: Simd> core::ops::BitAnd<i8x16<S>> for i8 {
303    type Output = i8x16<S>;
304    #[inline(always)]
305    fn bitand(self, rhs: i8x16<S>) -> Self::Output {
306        rhs.simd.and_i8x16(self.simd_into(rhs.simd), rhs)
307    }
308}
309impl<S: Simd> core::ops::BitOr for i8x16<S> {
310    type Output = Self;
311    #[doc = "Compute the bitwise OR of two vectors."]
312    #[inline(always)]
313    fn bitor(self, rhs: Self) -> Self::Output {
314        self.simd.or_i8x16(self, rhs)
315    }
316}
317impl<S: Simd> core::ops::BitOrAssign for i8x16<S> {
318    #[doc = "Compute the bitwise OR of two vectors."]
319    #[inline(always)]
320    fn bitor_assign(&mut self, rhs: Self) {
321        *self = self.simd.or_i8x16(*self, rhs);
322    }
323}
324impl<S: Simd> core::ops::BitOr<i8> for i8x16<S> {
325    type Output = Self;
326    #[inline(always)]
327    fn bitor(self, rhs: i8) -> Self::Output {
328        self.simd.or_i8x16(self, rhs.simd_into(self.simd))
329    }
330}
331impl<S: Simd> core::ops::BitOrAssign<i8> for i8x16<S> {
332    #[inline(always)]
333    fn bitor_assign(&mut self, rhs: i8) {
334        *self = self.simd.or_i8x16(*self, rhs.simd_into(self.simd));
335    }
336}
337impl<S: Simd> core::ops::BitOr<i8x16<S>> for i8 {
338    type Output = i8x16<S>;
339    #[inline(always)]
340    fn bitor(self, rhs: i8x16<S>) -> Self::Output {
341        rhs.simd.or_i8x16(self.simd_into(rhs.simd), rhs)
342    }
343}
344impl<S: Simd> core::ops::BitXor for i8x16<S> {
345    type Output = Self;
346    #[doc = "Compute the bitwise XOR of two vectors."]
347    #[inline(always)]
348    fn bitxor(self, rhs: Self) -> Self::Output {
349        self.simd.xor_i8x16(self, rhs)
350    }
351}
352impl<S: Simd> core::ops::BitXorAssign for i8x16<S> {
353    #[doc = "Compute the bitwise XOR of two vectors."]
354    #[inline(always)]
355    fn bitxor_assign(&mut self, rhs: Self) {
356        *self = self.simd.xor_i8x16(*self, rhs);
357    }
358}
359impl<S: Simd> core::ops::BitXor<i8> for i8x16<S> {
360    type Output = Self;
361    #[inline(always)]
362    fn bitxor(self, rhs: i8) -> Self::Output {
363        self.simd.xor_i8x16(self, rhs.simd_into(self.simd))
364    }
365}
366impl<S: Simd> core::ops::BitXorAssign<i8> for i8x16<S> {
367    #[inline(always)]
368    fn bitxor_assign(&mut self, rhs: i8) {
369        *self = self.simd.xor_i8x16(*self, rhs.simd_into(self.simd));
370    }
371}
372impl<S: Simd> core::ops::BitXor<i8x16<S>> for i8 {
373    type Output = i8x16<S>;
374    #[inline(always)]
375    fn bitxor(self, rhs: i8x16<S>) -> Self::Output {
376        rhs.simd.xor_i8x16(self.simd_into(rhs.simd), rhs)
377    }
378}
379impl<S: Simd> core::ops::Not for i8x16<S> {
380    type Output = Self;
381    #[doc = "Compute the bitwise NOT of the vector."]
382    #[inline(always)]
383    fn not(self) -> Self::Output {
384        self.simd.not_i8x16(self)
385    }
386}
387impl<S: Simd> core::ops::Shl<u32> for i8x16<S> {
388    type Output = Self;
389    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
390    #[inline(always)]
391    fn shl(self, rhs: u32) -> Self::Output {
392        self.simd.shl_i8x16(self, rhs)
393    }
394}
395impl<S: Simd> core::ops::ShlAssign<u32> for i8x16<S> {
396    #[inline(always)]
397    fn shl_assign(&mut self, rhs: u32) {
398        *self = self.simd.shl_i8x16(*self, rhs);
399    }
400}
401impl<S: Simd> core::ops::Shl for i8x16<S> {
402    type Output = Self;
403    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
404    #[inline(always)]
405    fn shl(self, rhs: Self) -> Self::Output {
406        self.simd.shlv_i8x16(self, rhs)
407    }
408}
409impl<S: Simd> core::ops::ShlAssign for i8x16<S> {
410    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
411    #[inline(always)]
412    fn shl_assign(&mut self, rhs: Self) {
413        *self = self.simd.shlv_i8x16(*self, rhs);
414    }
415}
416impl<S: Simd> core::ops::Shr<u32> for i8x16<S> {
417    type Output = Self;
418    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
419    #[inline(always)]
420    fn shr(self, rhs: u32) -> Self::Output {
421        self.simd.shr_i8x16(self, rhs)
422    }
423}
424impl<S: Simd> core::ops::ShrAssign<u32> for i8x16<S> {
425    #[inline(always)]
426    fn shr_assign(&mut self, rhs: u32) {
427        *self = self.simd.shr_i8x16(*self, rhs);
428    }
429}
430impl<S: Simd> core::ops::Shr for i8x16<S> {
431    type Output = Self;
432    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
433    #[inline(always)]
434    fn shr(self, rhs: Self) -> Self::Output {
435        self.simd.shrv_i8x16(self, rhs)
436    }
437}
438impl<S: Simd> core::ops::ShrAssign for i8x16<S> {
439    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
440    #[inline(always)]
441    fn shr_assign(&mut self, rhs: Self) {
442        *self = self.simd.shrv_i8x16(*self, rhs);
443    }
444}
445impl<S: Simd> core::ops::Add for u8x16<S> {
446    type Output = Self;
447    #[doc = "Add two vectors element-wise, wrapping on overflow."]
448    #[inline(always)]
449    fn add(self, rhs: Self) -> Self::Output {
450        self.simd.add_u8x16(self, rhs)
451    }
452}
453impl<S: Simd> core::ops::AddAssign for u8x16<S> {
454    #[doc = "Add two vectors element-wise, wrapping on overflow."]
455    #[inline(always)]
456    fn add_assign(&mut self, rhs: Self) {
457        *self = self.simd.add_u8x16(*self, rhs);
458    }
459}
460impl<S: Simd> core::ops::Add<u8> for u8x16<S> {
461    type Output = Self;
462    #[inline(always)]
463    fn add(self, rhs: u8) -> Self::Output {
464        self.simd.add_u8x16(self, rhs.simd_into(self.simd))
465    }
466}
467impl<S: Simd> core::ops::AddAssign<u8> for u8x16<S> {
468    #[inline(always)]
469    fn add_assign(&mut self, rhs: u8) {
470        *self = self.simd.add_u8x16(*self, rhs.simd_into(self.simd));
471    }
472}
473impl<S: Simd> core::ops::Add<u8x16<S>> for u8 {
474    type Output = u8x16<S>;
475    #[inline(always)]
476    fn add(self, rhs: u8x16<S>) -> Self::Output {
477        rhs.simd.add_u8x16(self.simd_into(rhs.simd), rhs)
478    }
479}
480impl<S: Simd> core::ops::Sub for u8x16<S> {
481    type Output = Self;
482    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
483    #[inline(always)]
484    fn sub(self, rhs: Self) -> Self::Output {
485        self.simd.sub_u8x16(self, rhs)
486    }
487}
488impl<S: Simd> core::ops::SubAssign for u8x16<S> {
489    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
490    #[inline(always)]
491    fn sub_assign(&mut self, rhs: Self) {
492        *self = self.simd.sub_u8x16(*self, rhs);
493    }
494}
495impl<S: Simd> core::ops::Sub<u8> for u8x16<S> {
496    type Output = Self;
497    #[inline(always)]
498    fn sub(self, rhs: u8) -> Self::Output {
499        self.simd.sub_u8x16(self, rhs.simd_into(self.simd))
500    }
501}
502impl<S: Simd> core::ops::SubAssign<u8> for u8x16<S> {
503    #[inline(always)]
504    fn sub_assign(&mut self, rhs: u8) {
505        *self = self.simd.sub_u8x16(*self, rhs.simd_into(self.simd));
506    }
507}
508impl<S: Simd> core::ops::Sub<u8x16<S>> for u8 {
509    type Output = u8x16<S>;
510    #[inline(always)]
511    fn sub(self, rhs: u8x16<S>) -> Self::Output {
512        rhs.simd.sub_u8x16(self.simd_into(rhs.simd), rhs)
513    }
514}
515impl<S: Simd> core::ops::Mul for u8x16<S> {
516    type Output = Self;
517    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
518    #[inline(always)]
519    fn mul(self, rhs: Self) -> Self::Output {
520        self.simd.mul_u8x16(self, rhs)
521    }
522}
523impl<S: Simd> core::ops::MulAssign for u8x16<S> {
524    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
525    #[inline(always)]
526    fn mul_assign(&mut self, rhs: Self) {
527        *self = self.simd.mul_u8x16(*self, rhs);
528    }
529}
530impl<S: Simd> core::ops::Mul<u8> for u8x16<S> {
531    type Output = Self;
532    #[inline(always)]
533    fn mul(self, rhs: u8) -> Self::Output {
534        self.simd.mul_u8x16(self, rhs.simd_into(self.simd))
535    }
536}
537impl<S: Simd> core::ops::MulAssign<u8> for u8x16<S> {
538    #[inline(always)]
539    fn mul_assign(&mut self, rhs: u8) {
540        *self = self.simd.mul_u8x16(*self, rhs.simd_into(self.simd));
541    }
542}
543impl<S: Simd> core::ops::Mul<u8x16<S>> for u8 {
544    type Output = u8x16<S>;
545    #[inline(always)]
546    fn mul(self, rhs: u8x16<S>) -> Self::Output {
547        rhs.simd.mul_u8x16(self.simd_into(rhs.simd), rhs)
548    }
549}
550impl<S: Simd> core::ops::BitAnd for u8x16<S> {
551    type Output = Self;
552    #[doc = "Compute the bitwise AND of two vectors."]
553    #[inline(always)]
554    fn bitand(self, rhs: Self) -> Self::Output {
555        self.simd.and_u8x16(self, rhs)
556    }
557}
558impl<S: Simd> core::ops::BitAndAssign for u8x16<S> {
559    #[doc = "Compute the bitwise AND of two vectors."]
560    #[inline(always)]
561    fn bitand_assign(&mut self, rhs: Self) {
562        *self = self.simd.and_u8x16(*self, rhs);
563    }
564}
565impl<S: Simd> core::ops::BitAnd<u8> for u8x16<S> {
566    type Output = Self;
567    #[inline(always)]
568    fn bitand(self, rhs: u8) -> Self::Output {
569        self.simd.and_u8x16(self, rhs.simd_into(self.simd))
570    }
571}
572impl<S: Simd> core::ops::BitAndAssign<u8> for u8x16<S> {
573    #[inline(always)]
574    fn bitand_assign(&mut self, rhs: u8) {
575        *self = self.simd.and_u8x16(*self, rhs.simd_into(self.simd));
576    }
577}
578impl<S: Simd> core::ops::BitAnd<u8x16<S>> for u8 {
579    type Output = u8x16<S>;
580    #[inline(always)]
581    fn bitand(self, rhs: u8x16<S>) -> Self::Output {
582        rhs.simd.and_u8x16(self.simd_into(rhs.simd), rhs)
583    }
584}
585impl<S: Simd> core::ops::BitOr for u8x16<S> {
586    type Output = Self;
587    #[doc = "Compute the bitwise OR of two vectors."]
588    #[inline(always)]
589    fn bitor(self, rhs: Self) -> Self::Output {
590        self.simd.or_u8x16(self, rhs)
591    }
592}
593impl<S: Simd> core::ops::BitOrAssign for u8x16<S> {
594    #[doc = "Compute the bitwise OR of two vectors."]
595    #[inline(always)]
596    fn bitor_assign(&mut self, rhs: Self) {
597        *self = self.simd.or_u8x16(*self, rhs);
598    }
599}
600impl<S: Simd> core::ops::BitOr<u8> for u8x16<S> {
601    type Output = Self;
602    #[inline(always)]
603    fn bitor(self, rhs: u8) -> Self::Output {
604        self.simd.or_u8x16(self, rhs.simd_into(self.simd))
605    }
606}
607impl<S: Simd> core::ops::BitOrAssign<u8> for u8x16<S> {
608    #[inline(always)]
609    fn bitor_assign(&mut self, rhs: u8) {
610        *self = self.simd.or_u8x16(*self, rhs.simd_into(self.simd));
611    }
612}
613impl<S: Simd> core::ops::BitOr<u8x16<S>> for u8 {
614    type Output = u8x16<S>;
615    #[inline(always)]
616    fn bitor(self, rhs: u8x16<S>) -> Self::Output {
617        rhs.simd.or_u8x16(self.simd_into(rhs.simd), rhs)
618    }
619}
620impl<S: Simd> core::ops::BitXor for u8x16<S> {
621    type Output = Self;
622    #[doc = "Compute the bitwise XOR of two vectors."]
623    #[inline(always)]
624    fn bitxor(self, rhs: Self) -> Self::Output {
625        self.simd.xor_u8x16(self, rhs)
626    }
627}
628impl<S: Simd> core::ops::BitXorAssign for u8x16<S> {
629    #[doc = "Compute the bitwise XOR of two vectors."]
630    #[inline(always)]
631    fn bitxor_assign(&mut self, rhs: Self) {
632        *self = self.simd.xor_u8x16(*self, rhs);
633    }
634}
635impl<S: Simd> core::ops::BitXor<u8> for u8x16<S> {
636    type Output = Self;
637    #[inline(always)]
638    fn bitxor(self, rhs: u8) -> Self::Output {
639        self.simd.xor_u8x16(self, rhs.simd_into(self.simd))
640    }
641}
642impl<S: Simd> core::ops::BitXorAssign<u8> for u8x16<S> {
643    #[inline(always)]
644    fn bitxor_assign(&mut self, rhs: u8) {
645        *self = self.simd.xor_u8x16(*self, rhs.simd_into(self.simd));
646    }
647}
648impl<S: Simd> core::ops::BitXor<u8x16<S>> for u8 {
649    type Output = u8x16<S>;
650    #[inline(always)]
651    fn bitxor(self, rhs: u8x16<S>) -> Self::Output {
652        rhs.simd.xor_u8x16(self.simd_into(rhs.simd), rhs)
653    }
654}
655impl<S: Simd> core::ops::Not for u8x16<S> {
656    type Output = Self;
657    #[doc = "Compute the bitwise NOT of the vector."]
658    #[inline(always)]
659    fn not(self) -> Self::Output {
660        self.simd.not_u8x16(self)
661    }
662}
663impl<S: Simd> core::ops::Shl<u32> for u8x16<S> {
664    type Output = Self;
665    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
666    #[inline(always)]
667    fn shl(self, rhs: u32) -> Self::Output {
668        self.simd.shl_u8x16(self, rhs)
669    }
670}
671impl<S: Simd> core::ops::ShlAssign<u32> for u8x16<S> {
672    #[inline(always)]
673    fn shl_assign(&mut self, rhs: u32) {
674        *self = self.simd.shl_u8x16(*self, rhs);
675    }
676}
677impl<S: Simd> core::ops::Shl for u8x16<S> {
678    type Output = Self;
679    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
680    #[inline(always)]
681    fn shl(self, rhs: Self) -> Self::Output {
682        self.simd.shlv_u8x16(self, rhs)
683    }
684}
685impl<S: Simd> core::ops::ShlAssign for u8x16<S> {
686    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
687    #[inline(always)]
688    fn shl_assign(&mut self, rhs: Self) {
689        *self = self.simd.shlv_u8x16(*self, rhs);
690    }
691}
692impl<S: Simd> core::ops::Shr<u32> for u8x16<S> {
693    type Output = Self;
694    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
695    #[inline(always)]
696    fn shr(self, rhs: u32) -> Self::Output {
697        self.simd.shr_u8x16(self, rhs)
698    }
699}
700impl<S: Simd> core::ops::ShrAssign<u32> for u8x16<S> {
701    #[inline(always)]
702    fn shr_assign(&mut self, rhs: u32) {
703        *self = self.simd.shr_u8x16(*self, rhs);
704    }
705}
706impl<S: Simd> core::ops::Shr for u8x16<S> {
707    type Output = Self;
708    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
709    #[inline(always)]
710    fn shr(self, rhs: Self) -> Self::Output {
711        self.simd.shrv_u8x16(self, rhs)
712    }
713}
714impl<S: Simd> core::ops::ShrAssign for u8x16<S> {
715    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
716    #[inline(always)]
717    fn shr_assign(&mut self, rhs: Self) {
718        *self = self.simd.shrv_u8x16(*self, rhs);
719    }
720}
721impl<S: Simd> core::ops::BitAnd for mask8x16<S> {
722    type Output = Self;
723    #[doc = "Compute the logical AND of two masks."]
724    #[inline(always)]
725    fn bitand(self, rhs: Self) -> Self::Output {
726        self.simd.and_mask8x16(self, rhs)
727    }
728}
729impl<S: Simd> core::ops::BitAndAssign for mask8x16<S> {
730    #[doc = "Compute the logical AND of two masks."]
731    #[inline(always)]
732    fn bitand_assign(&mut self, rhs: Self) {
733        *self = self.simd.and_mask8x16(*self, rhs);
734    }
735}
736impl<S: Simd> core::ops::BitAnd<i8> for mask8x16<S> {
737    type Output = Self;
738    #[inline(always)]
739    fn bitand(self, rhs: i8) -> Self::Output {
740        self.simd.and_mask8x16(self, rhs.simd_into(self.simd))
741    }
742}
743impl<S: Simd> core::ops::BitAndAssign<i8> for mask8x16<S> {
744    #[inline(always)]
745    fn bitand_assign(&mut self, rhs: i8) {
746        *self = self.simd.and_mask8x16(*self, rhs.simd_into(self.simd));
747    }
748}
749impl<S: Simd> core::ops::BitAnd<mask8x16<S>> for i8 {
750    type Output = mask8x16<S>;
751    #[inline(always)]
752    fn bitand(self, rhs: mask8x16<S>) -> Self::Output {
753        rhs.simd.and_mask8x16(self.simd_into(rhs.simd), rhs)
754    }
755}
756impl<S: Simd> core::ops::BitOr for mask8x16<S> {
757    type Output = Self;
758    #[doc = "Compute the logical OR of two masks."]
759    #[inline(always)]
760    fn bitor(self, rhs: Self) -> Self::Output {
761        self.simd.or_mask8x16(self, rhs)
762    }
763}
764impl<S: Simd> core::ops::BitOrAssign for mask8x16<S> {
765    #[doc = "Compute the logical OR of two masks."]
766    #[inline(always)]
767    fn bitor_assign(&mut self, rhs: Self) {
768        *self = self.simd.or_mask8x16(*self, rhs);
769    }
770}
771impl<S: Simd> core::ops::BitOr<i8> for mask8x16<S> {
772    type Output = Self;
773    #[inline(always)]
774    fn bitor(self, rhs: i8) -> Self::Output {
775        self.simd.or_mask8x16(self, rhs.simd_into(self.simd))
776    }
777}
778impl<S: Simd> core::ops::BitOrAssign<i8> for mask8x16<S> {
779    #[inline(always)]
780    fn bitor_assign(&mut self, rhs: i8) {
781        *self = self.simd.or_mask8x16(*self, rhs.simd_into(self.simd));
782    }
783}
784impl<S: Simd> core::ops::BitOr<mask8x16<S>> for i8 {
785    type Output = mask8x16<S>;
786    #[inline(always)]
787    fn bitor(self, rhs: mask8x16<S>) -> Self::Output {
788        rhs.simd.or_mask8x16(self.simd_into(rhs.simd), rhs)
789    }
790}
791impl<S: Simd> core::ops::BitXor for mask8x16<S> {
792    type Output = Self;
793    #[doc = "Compute the logical XOR of two masks."]
794    #[inline(always)]
795    fn bitxor(self, rhs: Self) -> Self::Output {
796        self.simd.xor_mask8x16(self, rhs)
797    }
798}
799impl<S: Simd> core::ops::BitXorAssign for mask8x16<S> {
800    #[doc = "Compute the logical XOR of two masks."]
801    #[inline(always)]
802    fn bitxor_assign(&mut self, rhs: Self) {
803        *self = self.simd.xor_mask8x16(*self, rhs);
804    }
805}
806impl<S: Simd> core::ops::BitXor<i8> for mask8x16<S> {
807    type Output = Self;
808    #[inline(always)]
809    fn bitxor(self, rhs: i8) -> Self::Output {
810        self.simd.xor_mask8x16(self, rhs.simd_into(self.simd))
811    }
812}
813impl<S: Simd> core::ops::BitXorAssign<i8> for mask8x16<S> {
814    #[inline(always)]
815    fn bitxor_assign(&mut self, rhs: i8) {
816        *self = self.simd.xor_mask8x16(*self, rhs.simd_into(self.simd));
817    }
818}
819impl<S: Simd> core::ops::BitXor<mask8x16<S>> for i8 {
820    type Output = mask8x16<S>;
821    #[inline(always)]
822    fn bitxor(self, rhs: mask8x16<S>) -> Self::Output {
823        rhs.simd.xor_mask8x16(self.simd_into(rhs.simd), rhs)
824    }
825}
826impl<S: Simd> core::ops::Not for mask8x16<S> {
827    type Output = Self;
828    #[doc = "Compute the logical NOT of the mask."]
829    #[inline(always)]
830    fn not(self) -> Self::Output {
831        self.simd.not_mask8x16(self)
832    }
833}
834impl<S: Simd> core::ops::Neg for i16x8<S> {
835    type Output = Self;
836    #[doc = "Negate each element of the vector, wrapping on overflow."]
837    #[inline(always)]
838    fn neg(self) -> Self::Output {
839        self.simd.neg_i16x8(self)
840    }
841}
842impl<S: Simd> core::ops::Add for i16x8<S> {
843    type Output = Self;
844    #[doc = "Add two vectors element-wise, wrapping on overflow."]
845    #[inline(always)]
846    fn add(self, rhs: Self) -> Self::Output {
847        self.simd.add_i16x8(self, rhs)
848    }
849}
850impl<S: Simd> core::ops::AddAssign for i16x8<S> {
851    #[doc = "Add two vectors element-wise, wrapping on overflow."]
852    #[inline(always)]
853    fn add_assign(&mut self, rhs: Self) {
854        *self = self.simd.add_i16x8(*self, rhs);
855    }
856}
857impl<S: Simd> core::ops::Add<i16> for i16x8<S> {
858    type Output = Self;
859    #[inline(always)]
860    fn add(self, rhs: i16) -> Self::Output {
861        self.simd.add_i16x8(self, rhs.simd_into(self.simd))
862    }
863}
864impl<S: Simd> core::ops::AddAssign<i16> for i16x8<S> {
865    #[inline(always)]
866    fn add_assign(&mut self, rhs: i16) {
867        *self = self.simd.add_i16x8(*self, rhs.simd_into(self.simd));
868    }
869}
870impl<S: Simd> core::ops::Add<i16x8<S>> for i16 {
871    type Output = i16x8<S>;
872    #[inline(always)]
873    fn add(self, rhs: i16x8<S>) -> Self::Output {
874        rhs.simd.add_i16x8(self.simd_into(rhs.simd), rhs)
875    }
876}
877impl<S: Simd> core::ops::Sub for i16x8<S> {
878    type Output = Self;
879    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
880    #[inline(always)]
881    fn sub(self, rhs: Self) -> Self::Output {
882        self.simd.sub_i16x8(self, rhs)
883    }
884}
885impl<S: Simd> core::ops::SubAssign for i16x8<S> {
886    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
887    #[inline(always)]
888    fn sub_assign(&mut self, rhs: Self) {
889        *self = self.simd.sub_i16x8(*self, rhs);
890    }
891}
892impl<S: Simd> core::ops::Sub<i16> for i16x8<S> {
893    type Output = Self;
894    #[inline(always)]
895    fn sub(self, rhs: i16) -> Self::Output {
896        self.simd.sub_i16x8(self, rhs.simd_into(self.simd))
897    }
898}
899impl<S: Simd> core::ops::SubAssign<i16> for i16x8<S> {
900    #[inline(always)]
901    fn sub_assign(&mut self, rhs: i16) {
902        *self = self.simd.sub_i16x8(*self, rhs.simd_into(self.simd));
903    }
904}
905impl<S: Simd> core::ops::Sub<i16x8<S>> for i16 {
906    type Output = i16x8<S>;
907    #[inline(always)]
908    fn sub(self, rhs: i16x8<S>) -> Self::Output {
909        rhs.simd.sub_i16x8(self.simd_into(rhs.simd), rhs)
910    }
911}
912impl<S: Simd> core::ops::Mul for i16x8<S> {
913    type Output = Self;
914    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
915    #[inline(always)]
916    fn mul(self, rhs: Self) -> Self::Output {
917        self.simd.mul_i16x8(self, rhs)
918    }
919}
920impl<S: Simd> core::ops::MulAssign for i16x8<S> {
921    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
922    #[inline(always)]
923    fn mul_assign(&mut self, rhs: Self) {
924        *self = self.simd.mul_i16x8(*self, rhs);
925    }
926}
927impl<S: Simd> core::ops::Mul<i16> for i16x8<S> {
928    type Output = Self;
929    #[inline(always)]
930    fn mul(self, rhs: i16) -> Self::Output {
931        self.simd.mul_i16x8(self, rhs.simd_into(self.simd))
932    }
933}
934impl<S: Simd> core::ops::MulAssign<i16> for i16x8<S> {
935    #[inline(always)]
936    fn mul_assign(&mut self, rhs: i16) {
937        *self = self.simd.mul_i16x8(*self, rhs.simd_into(self.simd));
938    }
939}
940impl<S: Simd> core::ops::Mul<i16x8<S>> for i16 {
941    type Output = i16x8<S>;
942    #[inline(always)]
943    fn mul(self, rhs: i16x8<S>) -> Self::Output {
944        rhs.simd.mul_i16x8(self.simd_into(rhs.simd), rhs)
945    }
946}
947impl<S: Simd> core::ops::BitAnd for i16x8<S> {
948    type Output = Self;
949    #[doc = "Compute the bitwise AND of two vectors."]
950    #[inline(always)]
951    fn bitand(self, rhs: Self) -> Self::Output {
952        self.simd.and_i16x8(self, rhs)
953    }
954}
955impl<S: Simd> core::ops::BitAndAssign for i16x8<S> {
956    #[doc = "Compute the bitwise AND of two vectors."]
957    #[inline(always)]
958    fn bitand_assign(&mut self, rhs: Self) {
959        *self = self.simd.and_i16x8(*self, rhs);
960    }
961}
962impl<S: Simd> core::ops::BitAnd<i16> for i16x8<S> {
963    type Output = Self;
964    #[inline(always)]
965    fn bitand(self, rhs: i16) -> Self::Output {
966        self.simd.and_i16x8(self, rhs.simd_into(self.simd))
967    }
968}
969impl<S: Simd> core::ops::BitAndAssign<i16> for i16x8<S> {
970    #[inline(always)]
971    fn bitand_assign(&mut self, rhs: i16) {
972        *self = self.simd.and_i16x8(*self, rhs.simd_into(self.simd));
973    }
974}
975impl<S: Simd> core::ops::BitAnd<i16x8<S>> for i16 {
976    type Output = i16x8<S>;
977    #[inline(always)]
978    fn bitand(self, rhs: i16x8<S>) -> Self::Output {
979        rhs.simd.and_i16x8(self.simd_into(rhs.simd), rhs)
980    }
981}
982impl<S: Simd> core::ops::BitOr for i16x8<S> {
983    type Output = Self;
984    #[doc = "Compute the bitwise OR of two vectors."]
985    #[inline(always)]
986    fn bitor(self, rhs: Self) -> Self::Output {
987        self.simd.or_i16x8(self, rhs)
988    }
989}
990impl<S: Simd> core::ops::BitOrAssign for i16x8<S> {
991    #[doc = "Compute the bitwise OR of two vectors."]
992    #[inline(always)]
993    fn bitor_assign(&mut self, rhs: Self) {
994        *self = self.simd.or_i16x8(*self, rhs);
995    }
996}
997impl<S: Simd> core::ops::BitOr<i16> for i16x8<S> {
998    type Output = Self;
999    #[inline(always)]
1000    fn bitor(self, rhs: i16) -> Self::Output {
1001        self.simd.or_i16x8(self, rhs.simd_into(self.simd))
1002    }
1003}
1004impl<S: Simd> core::ops::BitOrAssign<i16> for i16x8<S> {
1005    #[inline(always)]
1006    fn bitor_assign(&mut self, rhs: i16) {
1007        *self = self.simd.or_i16x8(*self, rhs.simd_into(self.simd));
1008    }
1009}
1010impl<S: Simd> core::ops::BitOr<i16x8<S>> for i16 {
1011    type Output = i16x8<S>;
1012    #[inline(always)]
1013    fn bitor(self, rhs: i16x8<S>) -> Self::Output {
1014        rhs.simd.or_i16x8(self.simd_into(rhs.simd), rhs)
1015    }
1016}
1017impl<S: Simd> core::ops::BitXor for i16x8<S> {
1018    type Output = Self;
1019    #[doc = "Compute the bitwise XOR of two vectors."]
1020    #[inline(always)]
1021    fn bitxor(self, rhs: Self) -> Self::Output {
1022        self.simd.xor_i16x8(self, rhs)
1023    }
1024}
1025impl<S: Simd> core::ops::BitXorAssign for i16x8<S> {
1026    #[doc = "Compute the bitwise XOR of two vectors."]
1027    #[inline(always)]
1028    fn bitxor_assign(&mut self, rhs: Self) {
1029        *self = self.simd.xor_i16x8(*self, rhs);
1030    }
1031}
1032impl<S: Simd> core::ops::BitXor<i16> for i16x8<S> {
1033    type Output = Self;
1034    #[inline(always)]
1035    fn bitxor(self, rhs: i16) -> Self::Output {
1036        self.simd.xor_i16x8(self, rhs.simd_into(self.simd))
1037    }
1038}
1039impl<S: Simd> core::ops::BitXorAssign<i16> for i16x8<S> {
1040    #[inline(always)]
1041    fn bitxor_assign(&mut self, rhs: i16) {
1042        *self = self.simd.xor_i16x8(*self, rhs.simd_into(self.simd));
1043    }
1044}
1045impl<S: Simd> core::ops::BitXor<i16x8<S>> for i16 {
1046    type Output = i16x8<S>;
1047    #[inline(always)]
1048    fn bitxor(self, rhs: i16x8<S>) -> Self::Output {
1049        rhs.simd.xor_i16x8(self.simd_into(rhs.simd), rhs)
1050    }
1051}
1052impl<S: Simd> core::ops::Not for i16x8<S> {
1053    type Output = Self;
1054    #[doc = "Compute the bitwise NOT of the vector."]
1055    #[inline(always)]
1056    fn not(self) -> Self::Output {
1057        self.simd.not_i16x8(self)
1058    }
1059}
1060impl<S: Simd> core::ops::Shl<u32> for i16x8<S> {
1061    type Output = Self;
1062    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
1063    #[inline(always)]
1064    fn shl(self, rhs: u32) -> Self::Output {
1065        self.simd.shl_i16x8(self, rhs)
1066    }
1067}
1068impl<S: Simd> core::ops::ShlAssign<u32> for i16x8<S> {
1069    #[inline(always)]
1070    fn shl_assign(&mut self, rhs: u32) {
1071        *self = self.simd.shl_i16x8(*self, rhs);
1072    }
1073}
1074impl<S: Simd> core::ops::Shl for i16x8<S> {
1075    type Output = Self;
1076    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1077    #[inline(always)]
1078    fn shl(self, rhs: Self) -> Self::Output {
1079        self.simd.shlv_i16x8(self, rhs)
1080    }
1081}
1082impl<S: Simd> core::ops::ShlAssign for i16x8<S> {
1083    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1084    #[inline(always)]
1085    fn shl_assign(&mut self, rhs: Self) {
1086        *self = self.simd.shlv_i16x8(*self, rhs);
1087    }
1088}
1089impl<S: Simd> core::ops::Shr<u32> for i16x8<S> {
1090    type Output = Self;
1091    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
1092    #[inline(always)]
1093    fn shr(self, rhs: u32) -> Self::Output {
1094        self.simd.shr_i16x8(self, rhs)
1095    }
1096}
1097impl<S: Simd> core::ops::ShrAssign<u32> for i16x8<S> {
1098    #[inline(always)]
1099    fn shr_assign(&mut self, rhs: u32) {
1100        *self = self.simd.shr_i16x8(*self, rhs);
1101    }
1102}
1103impl<S: Simd> core::ops::Shr for i16x8<S> {
1104    type Output = Self;
1105    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1106    #[inline(always)]
1107    fn shr(self, rhs: Self) -> Self::Output {
1108        self.simd.shrv_i16x8(self, rhs)
1109    }
1110}
1111impl<S: Simd> core::ops::ShrAssign for i16x8<S> {
1112    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1113    #[inline(always)]
1114    fn shr_assign(&mut self, rhs: Self) {
1115        *self = self.simd.shrv_i16x8(*self, rhs);
1116    }
1117}
1118impl<S: Simd> core::ops::Add for u16x8<S> {
1119    type Output = Self;
1120    #[doc = "Add two vectors element-wise, wrapping on overflow."]
1121    #[inline(always)]
1122    fn add(self, rhs: Self) -> Self::Output {
1123        self.simd.add_u16x8(self, rhs)
1124    }
1125}
1126impl<S: Simd> core::ops::AddAssign for u16x8<S> {
1127    #[doc = "Add two vectors element-wise, wrapping on overflow."]
1128    #[inline(always)]
1129    fn add_assign(&mut self, rhs: Self) {
1130        *self = self.simd.add_u16x8(*self, rhs);
1131    }
1132}
1133impl<S: Simd> core::ops::Add<u16> for u16x8<S> {
1134    type Output = Self;
1135    #[inline(always)]
1136    fn add(self, rhs: u16) -> Self::Output {
1137        self.simd.add_u16x8(self, rhs.simd_into(self.simd))
1138    }
1139}
1140impl<S: Simd> core::ops::AddAssign<u16> for u16x8<S> {
1141    #[inline(always)]
1142    fn add_assign(&mut self, rhs: u16) {
1143        *self = self.simd.add_u16x8(*self, rhs.simd_into(self.simd));
1144    }
1145}
1146impl<S: Simd> core::ops::Add<u16x8<S>> for u16 {
1147    type Output = u16x8<S>;
1148    #[inline(always)]
1149    fn add(self, rhs: u16x8<S>) -> Self::Output {
1150        rhs.simd.add_u16x8(self.simd_into(rhs.simd), rhs)
1151    }
1152}
1153impl<S: Simd> core::ops::Sub for u16x8<S> {
1154    type Output = Self;
1155    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
1156    #[inline(always)]
1157    fn sub(self, rhs: Self) -> Self::Output {
1158        self.simd.sub_u16x8(self, rhs)
1159    }
1160}
1161impl<S: Simd> core::ops::SubAssign for u16x8<S> {
1162    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
1163    #[inline(always)]
1164    fn sub_assign(&mut self, rhs: Self) {
1165        *self = self.simd.sub_u16x8(*self, rhs);
1166    }
1167}
1168impl<S: Simd> core::ops::Sub<u16> for u16x8<S> {
1169    type Output = Self;
1170    #[inline(always)]
1171    fn sub(self, rhs: u16) -> Self::Output {
1172        self.simd.sub_u16x8(self, rhs.simd_into(self.simd))
1173    }
1174}
1175impl<S: Simd> core::ops::SubAssign<u16> for u16x8<S> {
1176    #[inline(always)]
1177    fn sub_assign(&mut self, rhs: u16) {
1178        *self = self.simd.sub_u16x8(*self, rhs.simd_into(self.simd));
1179    }
1180}
1181impl<S: Simd> core::ops::Sub<u16x8<S>> for u16 {
1182    type Output = u16x8<S>;
1183    #[inline(always)]
1184    fn sub(self, rhs: u16x8<S>) -> Self::Output {
1185        rhs.simd.sub_u16x8(self.simd_into(rhs.simd), rhs)
1186    }
1187}
1188impl<S: Simd> core::ops::Mul for u16x8<S> {
1189    type Output = Self;
1190    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
1191    #[inline(always)]
1192    fn mul(self, rhs: Self) -> Self::Output {
1193        self.simd.mul_u16x8(self, rhs)
1194    }
1195}
1196impl<S: Simd> core::ops::MulAssign for u16x8<S> {
1197    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
1198    #[inline(always)]
1199    fn mul_assign(&mut self, rhs: Self) {
1200        *self = self.simd.mul_u16x8(*self, rhs);
1201    }
1202}
1203impl<S: Simd> core::ops::Mul<u16> for u16x8<S> {
1204    type Output = Self;
1205    #[inline(always)]
1206    fn mul(self, rhs: u16) -> Self::Output {
1207        self.simd.mul_u16x8(self, rhs.simd_into(self.simd))
1208    }
1209}
1210impl<S: Simd> core::ops::MulAssign<u16> for u16x8<S> {
1211    #[inline(always)]
1212    fn mul_assign(&mut self, rhs: u16) {
1213        *self = self.simd.mul_u16x8(*self, rhs.simd_into(self.simd));
1214    }
1215}
1216impl<S: Simd> core::ops::Mul<u16x8<S>> for u16 {
1217    type Output = u16x8<S>;
1218    #[inline(always)]
1219    fn mul(self, rhs: u16x8<S>) -> Self::Output {
1220        rhs.simd.mul_u16x8(self.simd_into(rhs.simd), rhs)
1221    }
1222}
1223impl<S: Simd> core::ops::BitAnd for u16x8<S> {
1224    type Output = Self;
1225    #[doc = "Compute the bitwise AND of two vectors."]
1226    #[inline(always)]
1227    fn bitand(self, rhs: Self) -> Self::Output {
1228        self.simd.and_u16x8(self, rhs)
1229    }
1230}
1231impl<S: Simd> core::ops::BitAndAssign for u16x8<S> {
1232    #[doc = "Compute the bitwise AND of two vectors."]
1233    #[inline(always)]
1234    fn bitand_assign(&mut self, rhs: Self) {
1235        *self = self.simd.and_u16x8(*self, rhs);
1236    }
1237}
1238impl<S: Simd> core::ops::BitAnd<u16> for u16x8<S> {
1239    type Output = Self;
1240    #[inline(always)]
1241    fn bitand(self, rhs: u16) -> Self::Output {
1242        self.simd.and_u16x8(self, rhs.simd_into(self.simd))
1243    }
1244}
1245impl<S: Simd> core::ops::BitAndAssign<u16> for u16x8<S> {
1246    #[inline(always)]
1247    fn bitand_assign(&mut self, rhs: u16) {
1248        *self = self.simd.and_u16x8(*self, rhs.simd_into(self.simd));
1249    }
1250}
1251impl<S: Simd> core::ops::BitAnd<u16x8<S>> for u16 {
1252    type Output = u16x8<S>;
1253    #[inline(always)]
1254    fn bitand(self, rhs: u16x8<S>) -> Self::Output {
1255        rhs.simd.and_u16x8(self.simd_into(rhs.simd), rhs)
1256    }
1257}
1258impl<S: Simd> core::ops::BitOr for u16x8<S> {
1259    type Output = Self;
1260    #[doc = "Compute the bitwise OR of two vectors."]
1261    #[inline(always)]
1262    fn bitor(self, rhs: Self) -> Self::Output {
1263        self.simd.or_u16x8(self, rhs)
1264    }
1265}
1266impl<S: Simd> core::ops::BitOrAssign for u16x8<S> {
1267    #[doc = "Compute the bitwise OR of two vectors."]
1268    #[inline(always)]
1269    fn bitor_assign(&mut self, rhs: Self) {
1270        *self = self.simd.or_u16x8(*self, rhs);
1271    }
1272}
1273impl<S: Simd> core::ops::BitOr<u16> for u16x8<S> {
1274    type Output = Self;
1275    #[inline(always)]
1276    fn bitor(self, rhs: u16) -> Self::Output {
1277        self.simd.or_u16x8(self, rhs.simd_into(self.simd))
1278    }
1279}
1280impl<S: Simd> core::ops::BitOrAssign<u16> for u16x8<S> {
1281    #[inline(always)]
1282    fn bitor_assign(&mut self, rhs: u16) {
1283        *self = self.simd.or_u16x8(*self, rhs.simd_into(self.simd));
1284    }
1285}
1286impl<S: Simd> core::ops::BitOr<u16x8<S>> for u16 {
1287    type Output = u16x8<S>;
1288    #[inline(always)]
1289    fn bitor(self, rhs: u16x8<S>) -> Self::Output {
1290        rhs.simd.or_u16x8(self.simd_into(rhs.simd), rhs)
1291    }
1292}
1293impl<S: Simd> core::ops::BitXor for u16x8<S> {
1294    type Output = Self;
1295    #[doc = "Compute the bitwise XOR of two vectors."]
1296    #[inline(always)]
1297    fn bitxor(self, rhs: Self) -> Self::Output {
1298        self.simd.xor_u16x8(self, rhs)
1299    }
1300}
1301impl<S: Simd> core::ops::BitXorAssign for u16x8<S> {
1302    #[doc = "Compute the bitwise XOR of two vectors."]
1303    #[inline(always)]
1304    fn bitxor_assign(&mut self, rhs: Self) {
1305        *self = self.simd.xor_u16x8(*self, rhs);
1306    }
1307}
1308impl<S: Simd> core::ops::BitXor<u16> for u16x8<S> {
1309    type Output = Self;
1310    #[inline(always)]
1311    fn bitxor(self, rhs: u16) -> Self::Output {
1312        self.simd.xor_u16x8(self, rhs.simd_into(self.simd))
1313    }
1314}
1315impl<S: Simd> core::ops::BitXorAssign<u16> for u16x8<S> {
1316    #[inline(always)]
1317    fn bitxor_assign(&mut self, rhs: u16) {
1318        *self = self.simd.xor_u16x8(*self, rhs.simd_into(self.simd));
1319    }
1320}
1321impl<S: Simd> core::ops::BitXor<u16x8<S>> for u16 {
1322    type Output = u16x8<S>;
1323    #[inline(always)]
1324    fn bitxor(self, rhs: u16x8<S>) -> Self::Output {
1325        rhs.simd.xor_u16x8(self.simd_into(rhs.simd), rhs)
1326    }
1327}
1328impl<S: Simd> core::ops::Not for u16x8<S> {
1329    type Output = Self;
1330    #[doc = "Compute the bitwise NOT of the vector."]
1331    #[inline(always)]
1332    fn not(self) -> Self::Output {
1333        self.simd.not_u16x8(self)
1334    }
1335}
1336impl<S: Simd> core::ops::Shl<u32> for u16x8<S> {
1337    type Output = Self;
1338    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
1339    #[inline(always)]
1340    fn shl(self, rhs: u32) -> Self::Output {
1341        self.simd.shl_u16x8(self, rhs)
1342    }
1343}
1344impl<S: Simd> core::ops::ShlAssign<u32> for u16x8<S> {
1345    #[inline(always)]
1346    fn shl_assign(&mut self, rhs: u32) {
1347        *self = self.simd.shl_u16x8(*self, rhs);
1348    }
1349}
1350impl<S: Simd> core::ops::Shl for u16x8<S> {
1351    type Output = Self;
1352    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1353    #[inline(always)]
1354    fn shl(self, rhs: Self) -> Self::Output {
1355        self.simd.shlv_u16x8(self, rhs)
1356    }
1357}
1358impl<S: Simd> core::ops::ShlAssign for u16x8<S> {
1359    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1360    #[inline(always)]
1361    fn shl_assign(&mut self, rhs: Self) {
1362        *self = self.simd.shlv_u16x8(*self, rhs);
1363    }
1364}
1365impl<S: Simd> core::ops::Shr<u32> for u16x8<S> {
1366    type Output = Self;
1367    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
1368    #[inline(always)]
1369    fn shr(self, rhs: u32) -> Self::Output {
1370        self.simd.shr_u16x8(self, rhs)
1371    }
1372}
1373impl<S: Simd> core::ops::ShrAssign<u32> for u16x8<S> {
1374    #[inline(always)]
1375    fn shr_assign(&mut self, rhs: u32) {
1376        *self = self.simd.shr_u16x8(*self, rhs);
1377    }
1378}
1379impl<S: Simd> core::ops::Shr for u16x8<S> {
1380    type Output = Self;
1381    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1382    #[inline(always)]
1383    fn shr(self, rhs: Self) -> Self::Output {
1384        self.simd.shrv_u16x8(self, rhs)
1385    }
1386}
1387impl<S: Simd> core::ops::ShrAssign for u16x8<S> {
1388    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1389    #[inline(always)]
1390    fn shr_assign(&mut self, rhs: Self) {
1391        *self = self.simd.shrv_u16x8(*self, rhs);
1392    }
1393}
1394impl<S: Simd> core::ops::BitAnd for mask16x8<S> {
1395    type Output = Self;
1396    #[doc = "Compute the logical AND of two masks."]
1397    #[inline(always)]
1398    fn bitand(self, rhs: Self) -> Self::Output {
1399        self.simd.and_mask16x8(self, rhs)
1400    }
1401}
1402impl<S: Simd> core::ops::BitAndAssign for mask16x8<S> {
1403    #[doc = "Compute the logical AND of two masks."]
1404    #[inline(always)]
1405    fn bitand_assign(&mut self, rhs: Self) {
1406        *self = self.simd.and_mask16x8(*self, rhs);
1407    }
1408}
1409impl<S: Simd> core::ops::BitAnd<i16> for mask16x8<S> {
1410    type Output = Self;
1411    #[inline(always)]
1412    fn bitand(self, rhs: i16) -> Self::Output {
1413        self.simd.and_mask16x8(self, rhs.simd_into(self.simd))
1414    }
1415}
1416impl<S: Simd> core::ops::BitAndAssign<i16> for mask16x8<S> {
1417    #[inline(always)]
1418    fn bitand_assign(&mut self, rhs: i16) {
1419        *self = self.simd.and_mask16x8(*self, rhs.simd_into(self.simd));
1420    }
1421}
1422impl<S: Simd> core::ops::BitAnd<mask16x8<S>> for i16 {
1423    type Output = mask16x8<S>;
1424    #[inline(always)]
1425    fn bitand(self, rhs: mask16x8<S>) -> Self::Output {
1426        rhs.simd.and_mask16x8(self.simd_into(rhs.simd), rhs)
1427    }
1428}
1429impl<S: Simd> core::ops::BitOr for mask16x8<S> {
1430    type Output = Self;
1431    #[doc = "Compute the logical OR of two masks."]
1432    #[inline(always)]
1433    fn bitor(self, rhs: Self) -> Self::Output {
1434        self.simd.or_mask16x8(self, rhs)
1435    }
1436}
1437impl<S: Simd> core::ops::BitOrAssign for mask16x8<S> {
1438    #[doc = "Compute the logical OR of two masks."]
1439    #[inline(always)]
1440    fn bitor_assign(&mut self, rhs: Self) {
1441        *self = self.simd.or_mask16x8(*self, rhs);
1442    }
1443}
1444impl<S: Simd> core::ops::BitOr<i16> for mask16x8<S> {
1445    type Output = Self;
1446    #[inline(always)]
1447    fn bitor(self, rhs: i16) -> Self::Output {
1448        self.simd.or_mask16x8(self, rhs.simd_into(self.simd))
1449    }
1450}
1451impl<S: Simd> core::ops::BitOrAssign<i16> for mask16x8<S> {
1452    #[inline(always)]
1453    fn bitor_assign(&mut self, rhs: i16) {
1454        *self = self.simd.or_mask16x8(*self, rhs.simd_into(self.simd));
1455    }
1456}
1457impl<S: Simd> core::ops::BitOr<mask16x8<S>> for i16 {
1458    type Output = mask16x8<S>;
1459    #[inline(always)]
1460    fn bitor(self, rhs: mask16x8<S>) -> Self::Output {
1461        rhs.simd.or_mask16x8(self.simd_into(rhs.simd), rhs)
1462    }
1463}
1464impl<S: Simd> core::ops::BitXor for mask16x8<S> {
1465    type Output = Self;
1466    #[doc = "Compute the logical XOR of two masks."]
1467    #[inline(always)]
1468    fn bitxor(self, rhs: Self) -> Self::Output {
1469        self.simd.xor_mask16x8(self, rhs)
1470    }
1471}
1472impl<S: Simd> core::ops::BitXorAssign for mask16x8<S> {
1473    #[doc = "Compute the logical XOR of two masks."]
1474    #[inline(always)]
1475    fn bitxor_assign(&mut self, rhs: Self) {
1476        *self = self.simd.xor_mask16x8(*self, rhs);
1477    }
1478}
1479impl<S: Simd> core::ops::BitXor<i16> for mask16x8<S> {
1480    type Output = Self;
1481    #[inline(always)]
1482    fn bitxor(self, rhs: i16) -> Self::Output {
1483        self.simd.xor_mask16x8(self, rhs.simd_into(self.simd))
1484    }
1485}
1486impl<S: Simd> core::ops::BitXorAssign<i16> for mask16x8<S> {
1487    #[inline(always)]
1488    fn bitxor_assign(&mut self, rhs: i16) {
1489        *self = self.simd.xor_mask16x8(*self, rhs.simd_into(self.simd));
1490    }
1491}
1492impl<S: Simd> core::ops::BitXor<mask16x8<S>> for i16 {
1493    type Output = mask16x8<S>;
1494    #[inline(always)]
1495    fn bitxor(self, rhs: mask16x8<S>) -> Self::Output {
1496        rhs.simd.xor_mask16x8(self.simd_into(rhs.simd), rhs)
1497    }
1498}
1499impl<S: Simd> core::ops::Not for mask16x8<S> {
1500    type Output = Self;
1501    #[doc = "Compute the logical NOT of the mask."]
1502    #[inline(always)]
1503    fn not(self) -> Self::Output {
1504        self.simd.not_mask16x8(self)
1505    }
1506}
1507impl<S: Simd> core::ops::Neg for i32x4<S> {
1508    type Output = Self;
1509    #[doc = "Negate each element of the vector, wrapping on overflow."]
1510    #[inline(always)]
1511    fn neg(self) -> Self::Output {
1512        self.simd.neg_i32x4(self)
1513    }
1514}
1515impl<S: Simd> core::ops::Add for i32x4<S> {
1516    type Output = Self;
1517    #[doc = "Add two vectors element-wise, wrapping on overflow."]
1518    #[inline(always)]
1519    fn add(self, rhs: Self) -> Self::Output {
1520        self.simd.add_i32x4(self, rhs)
1521    }
1522}
1523impl<S: Simd> core::ops::AddAssign for i32x4<S> {
1524    #[doc = "Add two vectors element-wise, wrapping on overflow."]
1525    #[inline(always)]
1526    fn add_assign(&mut self, rhs: Self) {
1527        *self = self.simd.add_i32x4(*self, rhs);
1528    }
1529}
1530impl<S: Simd> core::ops::Add<i32> for i32x4<S> {
1531    type Output = Self;
1532    #[inline(always)]
1533    fn add(self, rhs: i32) -> Self::Output {
1534        self.simd.add_i32x4(self, rhs.simd_into(self.simd))
1535    }
1536}
1537impl<S: Simd> core::ops::AddAssign<i32> for i32x4<S> {
1538    #[inline(always)]
1539    fn add_assign(&mut self, rhs: i32) {
1540        *self = self.simd.add_i32x4(*self, rhs.simd_into(self.simd));
1541    }
1542}
1543impl<S: Simd> core::ops::Add<i32x4<S>> for i32 {
1544    type Output = i32x4<S>;
1545    #[inline(always)]
1546    fn add(self, rhs: i32x4<S>) -> Self::Output {
1547        rhs.simd.add_i32x4(self.simd_into(rhs.simd), rhs)
1548    }
1549}
1550impl<S: Simd> core::ops::Sub for i32x4<S> {
1551    type Output = Self;
1552    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
1553    #[inline(always)]
1554    fn sub(self, rhs: Self) -> Self::Output {
1555        self.simd.sub_i32x4(self, rhs)
1556    }
1557}
1558impl<S: Simd> core::ops::SubAssign for i32x4<S> {
1559    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
1560    #[inline(always)]
1561    fn sub_assign(&mut self, rhs: Self) {
1562        *self = self.simd.sub_i32x4(*self, rhs);
1563    }
1564}
1565impl<S: Simd> core::ops::Sub<i32> for i32x4<S> {
1566    type Output = Self;
1567    #[inline(always)]
1568    fn sub(self, rhs: i32) -> Self::Output {
1569        self.simd.sub_i32x4(self, rhs.simd_into(self.simd))
1570    }
1571}
1572impl<S: Simd> core::ops::SubAssign<i32> for i32x4<S> {
1573    #[inline(always)]
1574    fn sub_assign(&mut self, rhs: i32) {
1575        *self = self.simd.sub_i32x4(*self, rhs.simd_into(self.simd));
1576    }
1577}
1578impl<S: Simd> core::ops::Sub<i32x4<S>> for i32 {
1579    type Output = i32x4<S>;
1580    #[inline(always)]
1581    fn sub(self, rhs: i32x4<S>) -> Self::Output {
1582        rhs.simd.sub_i32x4(self.simd_into(rhs.simd), rhs)
1583    }
1584}
1585impl<S: Simd> core::ops::Mul for i32x4<S> {
1586    type Output = Self;
1587    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
1588    #[inline(always)]
1589    fn mul(self, rhs: Self) -> Self::Output {
1590        self.simd.mul_i32x4(self, rhs)
1591    }
1592}
1593impl<S: Simd> core::ops::MulAssign for i32x4<S> {
1594    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
1595    #[inline(always)]
1596    fn mul_assign(&mut self, rhs: Self) {
1597        *self = self.simd.mul_i32x4(*self, rhs);
1598    }
1599}
1600impl<S: Simd> core::ops::Mul<i32> for i32x4<S> {
1601    type Output = Self;
1602    #[inline(always)]
1603    fn mul(self, rhs: i32) -> Self::Output {
1604        self.simd.mul_i32x4(self, rhs.simd_into(self.simd))
1605    }
1606}
1607impl<S: Simd> core::ops::MulAssign<i32> for i32x4<S> {
1608    #[inline(always)]
1609    fn mul_assign(&mut self, rhs: i32) {
1610        *self = self.simd.mul_i32x4(*self, rhs.simd_into(self.simd));
1611    }
1612}
1613impl<S: Simd> core::ops::Mul<i32x4<S>> for i32 {
1614    type Output = i32x4<S>;
1615    #[inline(always)]
1616    fn mul(self, rhs: i32x4<S>) -> Self::Output {
1617        rhs.simd.mul_i32x4(self.simd_into(rhs.simd), rhs)
1618    }
1619}
1620impl<S: Simd> core::ops::BitAnd for i32x4<S> {
1621    type Output = Self;
1622    #[doc = "Compute the bitwise AND of two vectors."]
1623    #[inline(always)]
1624    fn bitand(self, rhs: Self) -> Self::Output {
1625        self.simd.and_i32x4(self, rhs)
1626    }
1627}
1628impl<S: Simd> core::ops::BitAndAssign for i32x4<S> {
1629    #[doc = "Compute the bitwise AND of two vectors."]
1630    #[inline(always)]
1631    fn bitand_assign(&mut self, rhs: Self) {
1632        *self = self.simd.and_i32x4(*self, rhs);
1633    }
1634}
1635impl<S: Simd> core::ops::BitAnd<i32> for i32x4<S> {
1636    type Output = Self;
1637    #[inline(always)]
1638    fn bitand(self, rhs: i32) -> Self::Output {
1639        self.simd.and_i32x4(self, rhs.simd_into(self.simd))
1640    }
1641}
1642impl<S: Simd> core::ops::BitAndAssign<i32> for i32x4<S> {
1643    #[inline(always)]
1644    fn bitand_assign(&mut self, rhs: i32) {
1645        *self = self.simd.and_i32x4(*self, rhs.simd_into(self.simd));
1646    }
1647}
1648impl<S: Simd> core::ops::BitAnd<i32x4<S>> for i32 {
1649    type Output = i32x4<S>;
1650    #[inline(always)]
1651    fn bitand(self, rhs: i32x4<S>) -> Self::Output {
1652        rhs.simd.and_i32x4(self.simd_into(rhs.simd), rhs)
1653    }
1654}
1655impl<S: Simd> core::ops::BitOr for i32x4<S> {
1656    type Output = Self;
1657    #[doc = "Compute the bitwise OR of two vectors."]
1658    #[inline(always)]
1659    fn bitor(self, rhs: Self) -> Self::Output {
1660        self.simd.or_i32x4(self, rhs)
1661    }
1662}
1663impl<S: Simd> core::ops::BitOrAssign for i32x4<S> {
1664    #[doc = "Compute the bitwise OR of two vectors."]
1665    #[inline(always)]
1666    fn bitor_assign(&mut self, rhs: Self) {
1667        *self = self.simd.or_i32x4(*self, rhs);
1668    }
1669}
1670impl<S: Simd> core::ops::BitOr<i32> for i32x4<S> {
1671    type Output = Self;
1672    #[inline(always)]
1673    fn bitor(self, rhs: i32) -> Self::Output {
1674        self.simd.or_i32x4(self, rhs.simd_into(self.simd))
1675    }
1676}
1677impl<S: Simd> core::ops::BitOrAssign<i32> for i32x4<S> {
1678    #[inline(always)]
1679    fn bitor_assign(&mut self, rhs: i32) {
1680        *self = self.simd.or_i32x4(*self, rhs.simd_into(self.simd));
1681    }
1682}
1683impl<S: Simd> core::ops::BitOr<i32x4<S>> for i32 {
1684    type Output = i32x4<S>;
1685    #[inline(always)]
1686    fn bitor(self, rhs: i32x4<S>) -> Self::Output {
1687        rhs.simd.or_i32x4(self.simd_into(rhs.simd), rhs)
1688    }
1689}
1690impl<S: Simd> core::ops::BitXor for i32x4<S> {
1691    type Output = Self;
1692    #[doc = "Compute the bitwise XOR of two vectors."]
1693    #[inline(always)]
1694    fn bitxor(self, rhs: Self) -> Self::Output {
1695        self.simd.xor_i32x4(self, rhs)
1696    }
1697}
1698impl<S: Simd> core::ops::BitXorAssign for i32x4<S> {
1699    #[doc = "Compute the bitwise XOR of two vectors."]
1700    #[inline(always)]
1701    fn bitxor_assign(&mut self, rhs: Self) {
1702        *self = self.simd.xor_i32x4(*self, rhs);
1703    }
1704}
1705impl<S: Simd> core::ops::BitXor<i32> for i32x4<S> {
1706    type Output = Self;
1707    #[inline(always)]
1708    fn bitxor(self, rhs: i32) -> Self::Output {
1709        self.simd.xor_i32x4(self, rhs.simd_into(self.simd))
1710    }
1711}
1712impl<S: Simd> core::ops::BitXorAssign<i32> for i32x4<S> {
1713    #[inline(always)]
1714    fn bitxor_assign(&mut self, rhs: i32) {
1715        *self = self.simd.xor_i32x4(*self, rhs.simd_into(self.simd));
1716    }
1717}
1718impl<S: Simd> core::ops::BitXor<i32x4<S>> for i32 {
1719    type Output = i32x4<S>;
1720    #[inline(always)]
1721    fn bitxor(self, rhs: i32x4<S>) -> Self::Output {
1722        rhs.simd.xor_i32x4(self.simd_into(rhs.simd), rhs)
1723    }
1724}
1725impl<S: Simd> core::ops::Not for i32x4<S> {
1726    type Output = Self;
1727    #[doc = "Compute the bitwise NOT of the vector."]
1728    #[inline(always)]
1729    fn not(self) -> Self::Output {
1730        self.simd.not_i32x4(self)
1731    }
1732}
1733impl<S: Simd> core::ops::Shl<u32> for i32x4<S> {
1734    type Output = Self;
1735    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
1736    #[inline(always)]
1737    fn shl(self, rhs: u32) -> Self::Output {
1738        self.simd.shl_i32x4(self, rhs)
1739    }
1740}
1741impl<S: Simd> core::ops::ShlAssign<u32> for i32x4<S> {
1742    #[inline(always)]
1743    fn shl_assign(&mut self, rhs: u32) {
1744        *self = self.simd.shl_i32x4(*self, rhs);
1745    }
1746}
1747impl<S: Simd> core::ops::Shl for i32x4<S> {
1748    type Output = Self;
1749    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1750    #[inline(always)]
1751    fn shl(self, rhs: Self) -> Self::Output {
1752        self.simd.shlv_i32x4(self, rhs)
1753    }
1754}
1755impl<S: Simd> core::ops::ShlAssign for i32x4<S> {
1756    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1757    #[inline(always)]
1758    fn shl_assign(&mut self, rhs: Self) {
1759        *self = self.simd.shlv_i32x4(*self, rhs);
1760    }
1761}
1762impl<S: Simd> core::ops::Shr<u32> for i32x4<S> {
1763    type Output = Self;
1764    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
1765    #[inline(always)]
1766    fn shr(self, rhs: u32) -> Self::Output {
1767        self.simd.shr_i32x4(self, rhs)
1768    }
1769}
1770impl<S: Simd> core::ops::ShrAssign<u32> for i32x4<S> {
1771    #[inline(always)]
1772    fn shr_assign(&mut self, rhs: u32) {
1773        *self = self.simd.shr_i32x4(*self, rhs);
1774    }
1775}
1776impl<S: Simd> core::ops::Shr for i32x4<S> {
1777    type Output = Self;
1778    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1779    #[inline(always)]
1780    fn shr(self, rhs: Self) -> Self::Output {
1781        self.simd.shrv_i32x4(self, rhs)
1782    }
1783}
1784impl<S: Simd> core::ops::ShrAssign for i32x4<S> {
1785    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
1786    #[inline(always)]
1787    fn shr_assign(&mut self, rhs: Self) {
1788        *self = self.simd.shrv_i32x4(*self, rhs);
1789    }
1790}
1791impl<S: Simd> core::ops::Add for u32x4<S> {
1792    type Output = Self;
1793    #[doc = "Add two vectors element-wise, wrapping on overflow."]
1794    #[inline(always)]
1795    fn add(self, rhs: Self) -> Self::Output {
1796        self.simd.add_u32x4(self, rhs)
1797    }
1798}
1799impl<S: Simd> core::ops::AddAssign for u32x4<S> {
1800    #[doc = "Add two vectors element-wise, wrapping on overflow."]
1801    #[inline(always)]
1802    fn add_assign(&mut self, rhs: Self) {
1803        *self = self.simd.add_u32x4(*self, rhs);
1804    }
1805}
1806impl<S: Simd> core::ops::Add<u32> for u32x4<S> {
1807    type Output = Self;
1808    #[inline(always)]
1809    fn add(self, rhs: u32) -> Self::Output {
1810        self.simd.add_u32x4(self, rhs.simd_into(self.simd))
1811    }
1812}
1813impl<S: Simd> core::ops::AddAssign<u32> for u32x4<S> {
1814    #[inline(always)]
1815    fn add_assign(&mut self, rhs: u32) {
1816        *self = self.simd.add_u32x4(*self, rhs.simd_into(self.simd));
1817    }
1818}
1819impl<S: Simd> core::ops::Add<u32x4<S>> for u32 {
1820    type Output = u32x4<S>;
1821    #[inline(always)]
1822    fn add(self, rhs: u32x4<S>) -> Self::Output {
1823        rhs.simd.add_u32x4(self.simd_into(rhs.simd), rhs)
1824    }
1825}
1826impl<S: Simd> core::ops::Sub for u32x4<S> {
1827    type Output = Self;
1828    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
1829    #[inline(always)]
1830    fn sub(self, rhs: Self) -> Self::Output {
1831        self.simd.sub_u32x4(self, rhs)
1832    }
1833}
1834impl<S: Simd> core::ops::SubAssign for u32x4<S> {
1835    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
1836    #[inline(always)]
1837    fn sub_assign(&mut self, rhs: Self) {
1838        *self = self.simd.sub_u32x4(*self, rhs);
1839    }
1840}
1841impl<S: Simd> core::ops::Sub<u32> for u32x4<S> {
1842    type Output = Self;
1843    #[inline(always)]
1844    fn sub(self, rhs: u32) -> Self::Output {
1845        self.simd.sub_u32x4(self, rhs.simd_into(self.simd))
1846    }
1847}
1848impl<S: Simd> core::ops::SubAssign<u32> for u32x4<S> {
1849    #[inline(always)]
1850    fn sub_assign(&mut self, rhs: u32) {
1851        *self = self.simd.sub_u32x4(*self, rhs.simd_into(self.simd));
1852    }
1853}
1854impl<S: Simd> core::ops::Sub<u32x4<S>> for u32 {
1855    type Output = u32x4<S>;
1856    #[inline(always)]
1857    fn sub(self, rhs: u32x4<S>) -> Self::Output {
1858        rhs.simd.sub_u32x4(self.simd_into(rhs.simd), rhs)
1859    }
1860}
1861impl<S: Simd> core::ops::Mul for u32x4<S> {
1862    type Output = Self;
1863    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
1864    #[inline(always)]
1865    fn mul(self, rhs: Self) -> Self::Output {
1866        self.simd.mul_u32x4(self, rhs)
1867    }
1868}
1869impl<S: Simd> core::ops::MulAssign for u32x4<S> {
1870    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
1871    #[inline(always)]
1872    fn mul_assign(&mut self, rhs: Self) {
1873        *self = self.simd.mul_u32x4(*self, rhs);
1874    }
1875}
1876impl<S: Simd> core::ops::Mul<u32> for u32x4<S> {
1877    type Output = Self;
1878    #[inline(always)]
1879    fn mul(self, rhs: u32) -> Self::Output {
1880        self.simd.mul_u32x4(self, rhs.simd_into(self.simd))
1881    }
1882}
1883impl<S: Simd> core::ops::MulAssign<u32> for u32x4<S> {
1884    #[inline(always)]
1885    fn mul_assign(&mut self, rhs: u32) {
1886        *self = self.simd.mul_u32x4(*self, rhs.simd_into(self.simd));
1887    }
1888}
1889impl<S: Simd> core::ops::Mul<u32x4<S>> for u32 {
1890    type Output = u32x4<S>;
1891    #[inline(always)]
1892    fn mul(self, rhs: u32x4<S>) -> Self::Output {
1893        rhs.simd.mul_u32x4(self.simd_into(rhs.simd), rhs)
1894    }
1895}
1896impl<S: Simd> core::ops::BitAnd for u32x4<S> {
1897    type Output = Self;
1898    #[doc = "Compute the bitwise AND of two vectors."]
1899    #[inline(always)]
1900    fn bitand(self, rhs: Self) -> Self::Output {
1901        self.simd.and_u32x4(self, rhs)
1902    }
1903}
1904impl<S: Simd> core::ops::BitAndAssign for u32x4<S> {
1905    #[doc = "Compute the bitwise AND of two vectors."]
1906    #[inline(always)]
1907    fn bitand_assign(&mut self, rhs: Self) {
1908        *self = self.simd.and_u32x4(*self, rhs);
1909    }
1910}
1911impl<S: Simd> core::ops::BitAnd<u32> for u32x4<S> {
1912    type Output = Self;
1913    #[inline(always)]
1914    fn bitand(self, rhs: u32) -> Self::Output {
1915        self.simd.and_u32x4(self, rhs.simd_into(self.simd))
1916    }
1917}
1918impl<S: Simd> core::ops::BitAndAssign<u32> for u32x4<S> {
1919    #[inline(always)]
1920    fn bitand_assign(&mut self, rhs: u32) {
1921        *self = self.simd.and_u32x4(*self, rhs.simd_into(self.simd));
1922    }
1923}
1924impl<S: Simd> core::ops::BitAnd<u32x4<S>> for u32 {
1925    type Output = u32x4<S>;
1926    #[inline(always)]
1927    fn bitand(self, rhs: u32x4<S>) -> Self::Output {
1928        rhs.simd.and_u32x4(self.simd_into(rhs.simd), rhs)
1929    }
1930}
1931impl<S: Simd> core::ops::BitOr for u32x4<S> {
1932    type Output = Self;
1933    #[doc = "Compute the bitwise OR of two vectors."]
1934    #[inline(always)]
1935    fn bitor(self, rhs: Self) -> Self::Output {
1936        self.simd.or_u32x4(self, rhs)
1937    }
1938}
1939impl<S: Simd> core::ops::BitOrAssign for u32x4<S> {
1940    #[doc = "Compute the bitwise OR of two vectors."]
1941    #[inline(always)]
1942    fn bitor_assign(&mut self, rhs: Self) {
1943        *self = self.simd.or_u32x4(*self, rhs);
1944    }
1945}
1946impl<S: Simd> core::ops::BitOr<u32> for u32x4<S> {
1947    type Output = Self;
1948    #[inline(always)]
1949    fn bitor(self, rhs: u32) -> Self::Output {
1950        self.simd.or_u32x4(self, rhs.simd_into(self.simd))
1951    }
1952}
1953impl<S: Simd> core::ops::BitOrAssign<u32> for u32x4<S> {
1954    #[inline(always)]
1955    fn bitor_assign(&mut self, rhs: u32) {
1956        *self = self.simd.or_u32x4(*self, rhs.simd_into(self.simd));
1957    }
1958}
1959impl<S: Simd> core::ops::BitOr<u32x4<S>> for u32 {
1960    type Output = u32x4<S>;
1961    #[inline(always)]
1962    fn bitor(self, rhs: u32x4<S>) -> Self::Output {
1963        rhs.simd.or_u32x4(self.simd_into(rhs.simd), rhs)
1964    }
1965}
1966impl<S: Simd> core::ops::BitXor for u32x4<S> {
1967    type Output = Self;
1968    #[doc = "Compute the bitwise XOR of two vectors."]
1969    #[inline(always)]
1970    fn bitxor(self, rhs: Self) -> Self::Output {
1971        self.simd.xor_u32x4(self, rhs)
1972    }
1973}
1974impl<S: Simd> core::ops::BitXorAssign for u32x4<S> {
1975    #[doc = "Compute the bitwise XOR of two vectors."]
1976    #[inline(always)]
1977    fn bitxor_assign(&mut self, rhs: Self) {
1978        *self = self.simd.xor_u32x4(*self, rhs);
1979    }
1980}
1981impl<S: Simd> core::ops::BitXor<u32> for u32x4<S> {
1982    type Output = Self;
1983    #[inline(always)]
1984    fn bitxor(self, rhs: u32) -> Self::Output {
1985        self.simd.xor_u32x4(self, rhs.simd_into(self.simd))
1986    }
1987}
1988impl<S: Simd> core::ops::BitXorAssign<u32> for u32x4<S> {
1989    #[inline(always)]
1990    fn bitxor_assign(&mut self, rhs: u32) {
1991        *self = self.simd.xor_u32x4(*self, rhs.simd_into(self.simd));
1992    }
1993}
1994impl<S: Simd> core::ops::BitXor<u32x4<S>> for u32 {
1995    type Output = u32x4<S>;
1996    #[inline(always)]
1997    fn bitxor(self, rhs: u32x4<S>) -> Self::Output {
1998        rhs.simd.xor_u32x4(self.simd_into(rhs.simd), rhs)
1999    }
2000}
2001impl<S: Simd> core::ops::Not for u32x4<S> {
2002    type Output = Self;
2003    #[doc = "Compute the bitwise NOT of the vector."]
2004    #[inline(always)]
2005    fn not(self) -> Self::Output {
2006        self.simd.not_u32x4(self)
2007    }
2008}
2009impl<S: Simd> core::ops::Shl<u32> for u32x4<S> {
2010    type Output = Self;
2011    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
2012    #[inline(always)]
2013    fn shl(self, rhs: u32) -> Self::Output {
2014        self.simd.shl_u32x4(self, rhs)
2015    }
2016}
2017impl<S: Simd> core::ops::ShlAssign<u32> for u32x4<S> {
2018    #[inline(always)]
2019    fn shl_assign(&mut self, rhs: u32) {
2020        *self = self.simd.shl_u32x4(*self, rhs);
2021    }
2022}
2023impl<S: Simd> core::ops::Shl for u32x4<S> {
2024    type Output = Self;
2025    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
2026    #[inline(always)]
2027    fn shl(self, rhs: Self) -> Self::Output {
2028        self.simd.shlv_u32x4(self, rhs)
2029    }
2030}
2031impl<S: Simd> core::ops::ShlAssign for u32x4<S> {
2032    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
2033    #[inline(always)]
2034    fn shl_assign(&mut self, rhs: Self) {
2035        *self = self.simd.shlv_u32x4(*self, rhs);
2036    }
2037}
2038impl<S: Simd> core::ops::Shr<u32> for u32x4<S> {
2039    type Output = Self;
2040    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
2041    #[inline(always)]
2042    fn shr(self, rhs: u32) -> Self::Output {
2043        self.simd.shr_u32x4(self, rhs)
2044    }
2045}
2046impl<S: Simd> core::ops::ShrAssign<u32> for u32x4<S> {
2047    #[inline(always)]
2048    fn shr_assign(&mut self, rhs: u32) {
2049        *self = self.simd.shr_u32x4(*self, rhs);
2050    }
2051}
2052impl<S: Simd> core::ops::Shr for u32x4<S> {
2053    type Output = Self;
2054    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
2055    #[inline(always)]
2056    fn shr(self, rhs: Self) -> Self::Output {
2057        self.simd.shrv_u32x4(self, rhs)
2058    }
2059}
2060impl<S: Simd> core::ops::ShrAssign for u32x4<S> {
2061    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
2062    #[inline(always)]
2063    fn shr_assign(&mut self, rhs: Self) {
2064        *self = self.simd.shrv_u32x4(*self, rhs);
2065    }
2066}
2067impl<S: Simd> core::ops::BitAnd for mask32x4<S> {
2068    type Output = Self;
2069    #[doc = "Compute the logical AND of two masks."]
2070    #[inline(always)]
2071    fn bitand(self, rhs: Self) -> Self::Output {
2072        self.simd.and_mask32x4(self, rhs)
2073    }
2074}
2075impl<S: Simd> core::ops::BitAndAssign for mask32x4<S> {
2076    #[doc = "Compute the logical AND of two masks."]
2077    #[inline(always)]
2078    fn bitand_assign(&mut self, rhs: Self) {
2079        *self = self.simd.and_mask32x4(*self, rhs);
2080    }
2081}
2082impl<S: Simd> core::ops::BitAnd<i32> for mask32x4<S> {
2083    type Output = Self;
2084    #[inline(always)]
2085    fn bitand(self, rhs: i32) -> Self::Output {
2086        self.simd.and_mask32x4(self, rhs.simd_into(self.simd))
2087    }
2088}
2089impl<S: Simd> core::ops::BitAndAssign<i32> for mask32x4<S> {
2090    #[inline(always)]
2091    fn bitand_assign(&mut self, rhs: i32) {
2092        *self = self.simd.and_mask32x4(*self, rhs.simd_into(self.simd));
2093    }
2094}
2095impl<S: Simd> core::ops::BitAnd<mask32x4<S>> for i32 {
2096    type Output = mask32x4<S>;
2097    #[inline(always)]
2098    fn bitand(self, rhs: mask32x4<S>) -> Self::Output {
2099        rhs.simd.and_mask32x4(self.simd_into(rhs.simd), rhs)
2100    }
2101}
2102impl<S: Simd> core::ops::BitOr for mask32x4<S> {
2103    type Output = Self;
2104    #[doc = "Compute the logical OR of two masks."]
2105    #[inline(always)]
2106    fn bitor(self, rhs: Self) -> Self::Output {
2107        self.simd.or_mask32x4(self, rhs)
2108    }
2109}
2110impl<S: Simd> core::ops::BitOrAssign for mask32x4<S> {
2111    #[doc = "Compute the logical OR of two masks."]
2112    #[inline(always)]
2113    fn bitor_assign(&mut self, rhs: Self) {
2114        *self = self.simd.or_mask32x4(*self, rhs);
2115    }
2116}
2117impl<S: Simd> core::ops::BitOr<i32> for mask32x4<S> {
2118    type Output = Self;
2119    #[inline(always)]
2120    fn bitor(self, rhs: i32) -> Self::Output {
2121        self.simd.or_mask32x4(self, rhs.simd_into(self.simd))
2122    }
2123}
2124impl<S: Simd> core::ops::BitOrAssign<i32> for mask32x4<S> {
2125    #[inline(always)]
2126    fn bitor_assign(&mut self, rhs: i32) {
2127        *self = self.simd.or_mask32x4(*self, rhs.simd_into(self.simd));
2128    }
2129}
2130impl<S: Simd> core::ops::BitOr<mask32x4<S>> for i32 {
2131    type Output = mask32x4<S>;
2132    #[inline(always)]
2133    fn bitor(self, rhs: mask32x4<S>) -> Self::Output {
2134        rhs.simd.or_mask32x4(self.simd_into(rhs.simd), rhs)
2135    }
2136}
2137impl<S: Simd> core::ops::BitXor for mask32x4<S> {
2138    type Output = Self;
2139    #[doc = "Compute the logical XOR of two masks."]
2140    #[inline(always)]
2141    fn bitxor(self, rhs: Self) -> Self::Output {
2142        self.simd.xor_mask32x4(self, rhs)
2143    }
2144}
2145impl<S: Simd> core::ops::BitXorAssign for mask32x4<S> {
2146    #[doc = "Compute the logical XOR of two masks."]
2147    #[inline(always)]
2148    fn bitxor_assign(&mut self, rhs: Self) {
2149        *self = self.simd.xor_mask32x4(*self, rhs);
2150    }
2151}
2152impl<S: Simd> core::ops::BitXor<i32> for mask32x4<S> {
2153    type Output = Self;
2154    #[inline(always)]
2155    fn bitxor(self, rhs: i32) -> Self::Output {
2156        self.simd.xor_mask32x4(self, rhs.simd_into(self.simd))
2157    }
2158}
2159impl<S: Simd> core::ops::BitXorAssign<i32> for mask32x4<S> {
2160    #[inline(always)]
2161    fn bitxor_assign(&mut self, rhs: i32) {
2162        *self = self.simd.xor_mask32x4(*self, rhs.simd_into(self.simd));
2163    }
2164}
2165impl<S: Simd> core::ops::BitXor<mask32x4<S>> for i32 {
2166    type Output = mask32x4<S>;
2167    #[inline(always)]
2168    fn bitxor(self, rhs: mask32x4<S>) -> Self::Output {
2169        rhs.simd.xor_mask32x4(self.simd_into(rhs.simd), rhs)
2170    }
2171}
2172impl<S: Simd> core::ops::Not for mask32x4<S> {
2173    type Output = Self;
2174    #[doc = "Compute the logical NOT of the mask."]
2175    #[inline(always)]
2176    fn not(self) -> Self::Output {
2177        self.simd.not_mask32x4(self)
2178    }
2179}
2180impl<S: Simd> core::ops::Neg for f64x2<S> {
2181    type Output = Self;
2182    #[doc = "Negate each element of the vector."]
2183    #[inline(always)]
2184    fn neg(self) -> Self::Output {
2185        self.simd.neg_f64x2(self)
2186    }
2187}
2188impl<S: Simd> core::ops::Add for f64x2<S> {
2189    type Output = Self;
2190    #[doc = "Add two vectors element-wise."]
2191    #[inline(always)]
2192    fn add(self, rhs: Self) -> Self::Output {
2193        self.simd.add_f64x2(self, rhs)
2194    }
2195}
2196impl<S: Simd> core::ops::AddAssign for f64x2<S> {
2197    #[doc = "Add two vectors element-wise."]
2198    #[inline(always)]
2199    fn add_assign(&mut self, rhs: Self) {
2200        *self = self.simd.add_f64x2(*self, rhs);
2201    }
2202}
2203impl<S: Simd> core::ops::Add<f64> for f64x2<S> {
2204    type Output = Self;
2205    #[inline(always)]
2206    fn add(self, rhs: f64) -> Self::Output {
2207        self.simd.add_f64x2(self, rhs.simd_into(self.simd))
2208    }
2209}
2210impl<S: Simd> core::ops::AddAssign<f64> for f64x2<S> {
2211    #[inline(always)]
2212    fn add_assign(&mut self, rhs: f64) {
2213        *self = self.simd.add_f64x2(*self, rhs.simd_into(self.simd));
2214    }
2215}
2216impl<S: Simd> core::ops::Add<f64x2<S>> for f64 {
2217    type Output = f64x2<S>;
2218    #[inline(always)]
2219    fn add(self, rhs: f64x2<S>) -> Self::Output {
2220        rhs.simd.add_f64x2(self.simd_into(rhs.simd), rhs)
2221    }
2222}
2223impl<S: Simd> core::ops::Sub for f64x2<S> {
2224    type Output = Self;
2225    #[doc = "Subtract two vectors element-wise."]
2226    #[inline(always)]
2227    fn sub(self, rhs: Self) -> Self::Output {
2228        self.simd.sub_f64x2(self, rhs)
2229    }
2230}
2231impl<S: Simd> core::ops::SubAssign for f64x2<S> {
2232    #[doc = "Subtract two vectors element-wise."]
2233    #[inline(always)]
2234    fn sub_assign(&mut self, rhs: Self) {
2235        *self = self.simd.sub_f64x2(*self, rhs);
2236    }
2237}
2238impl<S: Simd> core::ops::Sub<f64> for f64x2<S> {
2239    type Output = Self;
2240    #[inline(always)]
2241    fn sub(self, rhs: f64) -> Self::Output {
2242        self.simd.sub_f64x2(self, rhs.simd_into(self.simd))
2243    }
2244}
2245impl<S: Simd> core::ops::SubAssign<f64> for f64x2<S> {
2246    #[inline(always)]
2247    fn sub_assign(&mut self, rhs: f64) {
2248        *self = self.simd.sub_f64x2(*self, rhs.simd_into(self.simd));
2249    }
2250}
2251impl<S: Simd> core::ops::Sub<f64x2<S>> for f64 {
2252    type Output = f64x2<S>;
2253    #[inline(always)]
2254    fn sub(self, rhs: f64x2<S>) -> Self::Output {
2255        rhs.simd.sub_f64x2(self.simd_into(rhs.simd), rhs)
2256    }
2257}
2258impl<S: Simd> core::ops::Mul for f64x2<S> {
2259    type Output = Self;
2260    #[doc = "Multiply two vectors element-wise."]
2261    #[inline(always)]
2262    fn mul(self, rhs: Self) -> Self::Output {
2263        self.simd.mul_f64x2(self, rhs)
2264    }
2265}
2266impl<S: Simd> core::ops::MulAssign for f64x2<S> {
2267    #[doc = "Multiply two vectors element-wise."]
2268    #[inline(always)]
2269    fn mul_assign(&mut self, rhs: Self) {
2270        *self = self.simd.mul_f64x2(*self, rhs);
2271    }
2272}
2273impl<S: Simd> core::ops::Mul<f64> for f64x2<S> {
2274    type Output = Self;
2275    #[inline(always)]
2276    fn mul(self, rhs: f64) -> Self::Output {
2277        self.simd.mul_f64x2(self, rhs.simd_into(self.simd))
2278    }
2279}
2280impl<S: Simd> core::ops::MulAssign<f64> for f64x2<S> {
2281    #[inline(always)]
2282    fn mul_assign(&mut self, rhs: f64) {
2283        *self = self.simd.mul_f64x2(*self, rhs.simd_into(self.simd));
2284    }
2285}
2286impl<S: Simd> core::ops::Mul<f64x2<S>> for f64 {
2287    type Output = f64x2<S>;
2288    #[inline(always)]
2289    fn mul(self, rhs: f64x2<S>) -> Self::Output {
2290        rhs.simd.mul_f64x2(self.simd_into(rhs.simd), rhs)
2291    }
2292}
2293impl<S: Simd> core::ops::Div for f64x2<S> {
2294    type Output = Self;
2295    #[doc = "Divide two vectors element-wise."]
2296    #[inline(always)]
2297    fn div(self, rhs: Self) -> Self::Output {
2298        self.simd.div_f64x2(self, rhs)
2299    }
2300}
2301impl<S: Simd> core::ops::DivAssign for f64x2<S> {
2302    #[doc = "Divide two vectors element-wise."]
2303    #[inline(always)]
2304    fn div_assign(&mut self, rhs: Self) {
2305        *self = self.simd.div_f64x2(*self, rhs);
2306    }
2307}
2308impl<S: Simd> core::ops::Div<f64> for f64x2<S> {
2309    type Output = Self;
2310    #[inline(always)]
2311    fn div(self, rhs: f64) -> Self::Output {
2312        self.simd.div_f64x2(self, rhs.simd_into(self.simd))
2313    }
2314}
2315impl<S: Simd> core::ops::DivAssign<f64> for f64x2<S> {
2316    #[inline(always)]
2317    fn div_assign(&mut self, rhs: f64) {
2318        *self = self.simd.div_f64x2(*self, rhs.simd_into(self.simd));
2319    }
2320}
2321impl<S: Simd> core::ops::Div<f64x2<S>> for f64 {
2322    type Output = f64x2<S>;
2323    #[inline(always)]
2324    fn div(self, rhs: f64x2<S>) -> Self::Output {
2325        rhs.simd.div_f64x2(self.simd_into(rhs.simd), rhs)
2326    }
2327}
2328impl<S: Simd> core::ops::BitAnd for mask64x2<S> {
2329    type Output = Self;
2330    #[doc = "Compute the logical AND of two masks."]
2331    #[inline(always)]
2332    fn bitand(self, rhs: Self) -> Self::Output {
2333        self.simd.and_mask64x2(self, rhs)
2334    }
2335}
2336impl<S: Simd> core::ops::BitAndAssign for mask64x2<S> {
2337    #[doc = "Compute the logical AND of two masks."]
2338    #[inline(always)]
2339    fn bitand_assign(&mut self, rhs: Self) {
2340        *self = self.simd.and_mask64x2(*self, rhs);
2341    }
2342}
2343impl<S: Simd> core::ops::BitAnd<i64> for mask64x2<S> {
2344    type Output = Self;
2345    #[inline(always)]
2346    fn bitand(self, rhs: i64) -> Self::Output {
2347        self.simd.and_mask64x2(self, rhs.simd_into(self.simd))
2348    }
2349}
2350impl<S: Simd> core::ops::BitAndAssign<i64> for mask64x2<S> {
2351    #[inline(always)]
2352    fn bitand_assign(&mut self, rhs: i64) {
2353        *self = self.simd.and_mask64x2(*self, rhs.simd_into(self.simd));
2354    }
2355}
2356impl<S: Simd> core::ops::BitAnd<mask64x2<S>> for i64 {
2357    type Output = mask64x2<S>;
2358    #[inline(always)]
2359    fn bitand(self, rhs: mask64x2<S>) -> Self::Output {
2360        rhs.simd.and_mask64x2(self.simd_into(rhs.simd), rhs)
2361    }
2362}
2363impl<S: Simd> core::ops::BitOr for mask64x2<S> {
2364    type Output = Self;
2365    #[doc = "Compute the logical OR of two masks."]
2366    #[inline(always)]
2367    fn bitor(self, rhs: Self) -> Self::Output {
2368        self.simd.or_mask64x2(self, rhs)
2369    }
2370}
2371impl<S: Simd> core::ops::BitOrAssign for mask64x2<S> {
2372    #[doc = "Compute the logical OR of two masks."]
2373    #[inline(always)]
2374    fn bitor_assign(&mut self, rhs: Self) {
2375        *self = self.simd.or_mask64x2(*self, rhs);
2376    }
2377}
2378impl<S: Simd> core::ops::BitOr<i64> for mask64x2<S> {
2379    type Output = Self;
2380    #[inline(always)]
2381    fn bitor(self, rhs: i64) -> Self::Output {
2382        self.simd.or_mask64x2(self, rhs.simd_into(self.simd))
2383    }
2384}
2385impl<S: Simd> core::ops::BitOrAssign<i64> for mask64x2<S> {
2386    #[inline(always)]
2387    fn bitor_assign(&mut self, rhs: i64) {
2388        *self = self.simd.or_mask64x2(*self, rhs.simd_into(self.simd));
2389    }
2390}
2391impl<S: Simd> core::ops::BitOr<mask64x2<S>> for i64 {
2392    type Output = mask64x2<S>;
2393    #[inline(always)]
2394    fn bitor(self, rhs: mask64x2<S>) -> Self::Output {
2395        rhs.simd.or_mask64x2(self.simd_into(rhs.simd), rhs)
2396    }
2397}
2398impl<S: Simd> core::ops::BitXor for mask64x2<S> {
2399    type Output = Self;
2400    #[doc = "Compute the logical XOR of two masks."]
2401    #[inline(always)]
2402    fn bitxor(self, rhs: Self) -> Self::Output {
2403        self.simd.xor_mask64x2(self, rhs)
2404    }
2405}
2406impl<S: Simd> core::ops::BitXorAssign for mask64x2<S> {
2407    #[doc = "Compute the logical XOR of two masks."]
2408    #[inline(always)]
2409    fn bitxor_assign(&mut self, rhs: Self) {
2410        *self = self.simd.xor_mask64x2(*self, rhs);
2411    }
2412}
2413impl<S: Simd> core::ops::BitXor<i64> for mask64x2<S> {
2414    type Output = Self;
2415    #[inline(always)]
2416    fn bitxor(self, rhs: i64) -> Self::Output {
2417        self.simd.xor_mask64x2(self, rhs.simd_into(self.simd))
2418    }
2419}
2420impl<S: Simd> core::ops::BitXorAssign<i64> for mask64x2<S> {
2421    #[inline(always)]
2422    fn bitxor_assign(&mut self, rhs: i64) {
2423        *self = self.simd.xor_mask64x2(*self, rhs.simd_into(self.simd));
2424    }
2425}
2426impl<S: Simd> core::ops::BitXor<mask64x2<S>> for i64 {
2427    type Output = mask64x2<S>;
2428    #[inline(always)]
2429    fn bitxor(self, rhs: mask64x2<S>) -> Self::Output {
2430        rhs.simd.xor_mask64x2(self.simd_into(rhs.simd), rhs)
2431    }
2432}
2433impl<S: Simd> core::ops::Not for mask64x2<S> {
2434    type Output = Self;
2435    #[doc = "Compute the logical NOT of the mask."]
2436    #[inline(always)]
2437    fn not(self) -> Self::Output {
2438        self.simd.not_mask64x2(self)
2439    }
2440}
2441impl<S: Simd> core::ops::Neg for f32x8<S> {
2442    type Output = Self;
2443    #[doc = "Negate each element of the vector."]
2444    #[inline(always)]
2445    fn neg(self) -> Self::Output {
2446        self.simd.neg_f32x8(self)
2447    }
2448}
2449impl<S: Simd> core::ops::Add for f32x8<S> {
2450    type Output = Self;
2451    #[doc = "Add two vectors element-wise."]
2452    #[inline(always)]
2453    fn add(self, rhs: Self) -> Self::Output {
2454        self.simd.add_f32x8(self, rhs)
2455    }
2456}
2457impl<S: Simd> core::ops::AddAssign for f32x8<S> {
2458    #[doc = "Add two vectors element-wise."]
2459    #[inline(always)]
2460    fn add_assign(&mut self, rhs: Self) {
2461        *self = self.simd.add_f32x8(*self, rhs);
2462    }
2463}
2464impl<S: Simd> core::ops::Add<f32> for f32x8<S> {
2465    type Output = Self;
2466    #[inline(always)]
2467    fn add(self, rhs: f32) -> Self::Output {
2468        self.simd.add_f32x8(self, rhs.simd_into(self.simd))
2469    }
2470}
2471impl<S: Simd> core::ops::AddAssign<f32> for f32x8<S> {
2472    #[inline(always)]
2473    fn add_assign(&mut self, rhs: f32) {
2474        *self = self.simd.add_f32x8(*self, rhs.simd_into(self.simd));
2475    }
2476}
2477impl<S: Simd> core::ops::Add<f32x8<S>> for f32 {
2478    type Output = f32x8<S>;
2479    #[inline(always)]
2480    fn add(self, rhs: f32x8<S>) -> Self::Output {
2481        rhs.simd.add_f32x8(self.simd_into(rhs.simd), rhs)
2482    }
2483}
2484impl<S: Simd> core::ops::Sub for f32x8<S> {
2485    type Output = Self;
2486    #[doc = "Subtract two vectors element-wise."]
2487    #[inline(always)]
2488    fn sub(self, rhs: Self) -> Self::Output {
2489        self.simd.sub_f32x8(self, rhs)
2490    }
2491}
2492impl<S: Simd> core::ops::SubAssign for f32x8<S> {
2493    #[doc = "Subtract two vectors element-wise."]
2494    #[inline(always)]
2495    fn sub_assign(&mut self, rhs: Self) {
2496        *self = self.simd.sub_f32x8(*self, rhs);
2497    }
2498}
2499impl<S: Simd> core::ops::Sub<f32> for f32x8<S> {
2500    type Output = Self;
2501    #[inline(always)]
2502    fn sub(self, rhs: f32) -> Self::Output {
2503        self.simd.sub_f32x8(self, rhs.simd_into(self.simd))
2504    }
2505}
2506impl<S: Simd> core::ops::SubAssign<f32> for f32x8<S> {
2507    #[inline(always)]
2508    fn sub_assign(&mut self, rhs: f32) {
2509        *self = self.simd.sub_f32x8(*self, rhs.simd_into(self.simd));
2510    }
2511}
2512impl<S: Simd> core::ops::Sub<f32x8<S>> for f32 {
2513    type Output = f32x8<S>;
2514    #[inline(always)]
2515    fn sub(self, rhs: f32x8<S>) -> Self::Output {
2516        rhs.simd.sub_f32x8(self.simd_into(rhs.simd), rhs)
2517    }
2518}
2519impl<S: Simd> core::ops::Mul for f32x8<S> {
2520    type Output = Self;
2521    #[doc = "Multiply two vectors element-wise."]
2522    #[inline(always)]
2523    fn mul(self, rhs: Self) -> Self::Output {
2524        self.simd.mul_f32x8(self, rhs)
2525    }
2526}
2527impl<S: Simd> core::ops::MulAssign for f32x8<S> {
2528    #[doc = "Multiply two vectors element-wise."]
2529    #[inline(always)]
2530    fn mul_assign(&mut self, rhs: Self) {
2531        *self = self.simd.mul_f32x8(*self, rhs);
2532    }
2533}
2534impl<S: Simd> core::ops::Mul<f32> for f32x8<S> {
2535    type Output = Self;
2536    #[inline(always)]
2537    fn mul(self, rhs: f32) -> Self::Output {
2538        self.simd.mul_f32x8(self, rhs.simd_into(self.simd))
2539    }
2540}
2541impl<S: Simd> core::ops::MulAssign<f32> for f32x8<S> {
2542    #[inline(always)]
2543    fn mul_assign(&mut self, rhs: f32) {
2544        *self = self.simd.mul_f32x8(*self, rhs.simd_into(self.simd));
2545    }
2546}
2547impl<S: Simd> core::ops::Mul<f32x8<S>> for f32 {
2548    type Output = f32x8<S>;
2549    #[inline(always)]
2550    fn mul(self, rhs: f32x8<S>) -> Self::Output {
2551        rhs.simd.mul_f32x8(self.simd_into(rhs.simd), rhs)
2552    }
2553}
2554impl<S: Simd> core::ops::Div for f32x8<S> {
2555    type Output = Self;
2556    #[doc = "Divide two vectors element-wise."]
2557    #[inline(always)]
2558    fn div(self, rhs: Self) -> Self::Output {
2559        self.simd.div_f32x8(self, rhs)
2560    }
2561}
2562impl<S: Simd> core::ops::DivAssign for f32x8<S> {
2563    #[doc = "Divide two vectors element-wise."]
2564    #[inline(always)]
2565    fn div_assign(&mut self, rhs: Self) {
2566        *self = self.simd.div_f32x8(*self, rhs);
2567    }
2568}
2569impl<S: Simd> core::ops::Div<f32> for f32x8<S> {
2570    type Output = Self;
2571    #[inline(always)]
2572    fn div(self, rhs: f32) -> Self::Output {
2573        self.simd.div_f32x8(self, rhs.simd_into(self.simd))
2574    }
2575}
2576impl<S: Simd> core::ops::DivAssign<f32> for f32x8<S> {
2577    #[inline(always)]
2578    fn div_assign(&mut self, rhs: f32) {
2579        *self = self.simd.div_f32x8(*self, rhs.simd_into(self.simd));
2580    }
2581}
2582impl<S: Simd> core::ops::Div<f32x8<S>> for f32 {
2583    type Output = f32x8<S>;
2584    #[inline(always)]
2585    fn div(self, rhs: f32x8<S>) -> Self::Output {
2586        rhs.simd.div_f32x8(self.simd_into(rhs.simd), rhs)
2587    }
2588}
2589impl<S: Simd> core::ops::Neg for i8x32<S> {
2590    type Output = Self;
2591    #[doc = "Negate each element of the vector, wrapping on overflow."]
2592    #[inline(always)]
2593    fn neg(self) -> Self::Output {
2594        self.simd.neg_i8x32(self)
2595    }
2596}
2597impl<S: Simd> core::ops::Add for i8x32<S> {
2598    type Output = Self;
2599    #[doc = "Add two vectors element-wise, wrapping on overflow."]
2600    #[inline(always)]
2601    fn add(self, rhs: Self) -> Self::Output {
2602        self.simd.add_i8x32(self, rhs)
2603    }
2604}
2605impl<S: Simd> core::ops::AddAssign for i8x32<S> {
2606    #[doc = "Add two vectors element-wise, wrapping on overflow."]
2607    #[inline(always)]
2608    fn add_assign(&mut self, rhs: Self) {
2609        *self = self.simd.add_i8x32(*self, rhs);
2610    }
2611}
2612impl<S: Simd> core::ops::Add<i8> for i8x32<S> {
2613    type Output = Self;
2614    #[inline(always)]
2615    fn add(self, rhs: i8) -> Self::Output {
2616        self.simd.add_i8x32(self, rhs.simd_into(self.simd))
2617    }
2618}
2619impl<S: Simd> core::ops::AddAssign<i8> for i8x32<S> {
2620    #[inline(always)]
2621    fn add_assign(&mut self, rhs: i8) {
2622        *self = self.simd.add_i8x32(*self, rhs.simd_into(self.simd));
2623    }
2624}
2625impl<S: Simd> core::ops::Add<i8x32<S>> for i8 {
2626    type Output = i8x32<S>;
2627    #[inline(always)]
2628    fn add(self, rhs: i8x32<S>) -> Self::Output {
2629        rhs.simd.add_i8x32(self.simd_into(rhs.simd), rhs)
2630    }
2631}
2632impl<S: Simd> core::ops::Sub for i8x32<S> {
2633    type Output = Self;
2634    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
2635    #[inline(always)]
2636    fn sub(self, rhs: Self) -> Self::Output {
2637        self.simd.sub_i8x32(self, rhs)
2638    }
2639}
2640impl<S: Simd> core::ops::SubAssign for i8x32<S> {
2641    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
2642    #[inline(always)]
2643    fn sub_assign(&mut self, rhs: Self) {
2644        *self = self.simd.sub_i8x32(*self, rhs);
2645    }
2646}
2647impl<S: Simd> core::ops::Sub<i8> for i8x32<S> {
2648    type Output = Self;
2649    #[inline(always)]
2650    fn sub(self, rhs: i8) -> Self::Output {
2651        self.simd.sub_i8x32(self, rhs.simd_into(self.simd))
2652    }
2653}
2654impl<S: Simd> core::ops::SubAssign<i8> for i8x32<S> {
2655    #[inline(always)]
2656    fn sub_assign(&mut self, rhs: i8) {
2657        *self = self.simd.sub_i8x32(*self, rhs.simd_into(self.simd));
2658    }
2659}
2660impl<S: Simd> core::ops::Sub<i8x32<S>> for i8 {
2661    type Output = i8x32<S>;
2662    #[inline(always)]
2663    fn sub(self, rhs: i8x32<S>) -> Self::Output {
2664        rhs.simd.sub_i8x32(self.simd_into(rhs.simd), rhs)
2665    }
2666}
2667impl<S: Simd> core::ops::Mul for i8x32<S> {
2668    type Output = Self;
2669    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
2670    #[inline(always)]
2671    fn mul(self, rhs: Self) -> Self::Output {
2672        self.simd.mul_i8x32(self, rhs)
2673    }
2674}
2675impl<S: Simd> core::ops::MulAssign for i8x32<S> {
2676    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
2677    #[inline(always)]
2678    fn mul_assign(&mut self, rhs: Self) {
2679        *self = self.simd.mul_i8x32(*self, rhs);
2680    }
2681}
2682impl<S: Simd> core::ops::Mul<i8> for i8x32<S> {
2683    type Output = Self;
2684    #[inline(always)]
2685    fn mul(self, rhs: i8) -> Self::Output {
2686        self.simd.mul_i8x32(self, rhs.simd_into(self.simd))
2687    }
2688}
2689impl<S: Simd> core::ops::MulAssign<i8> for i8x32<S> {
2690    #[inline(always)]
2691    fn mul_assign(&mut self, rhs: i8) {
2692        *self = self.simd.mul_i8x32(*self, rhs.simd_into(self.simd));
2693    }
2694}
2695impl<S: Simd> core::ops::Mul<i8x32<S>> for i8 {
2696    type Output = i8x32<S>;
2697    #[inline(always)]
2698    fn mul(self, rhs: i8x32<S>) -> Self::Output {
2699        rhs.simd.mul_i8x32(self.simd_into(rhs.simd), rhs)
2700    }
2701}
2702impl<S: Simd> core::ops::BitAnd for i8x32<S> {
2703    type Output = Self;
2704    #[doc = "Compute the bitwise AND of two vectors."]
2705    #[inline(always)]
2706    fn bitand(self, rhs: Self) -> Self::Output {
2707        self.simd.and_i8x32(self, rhs)
2708    }
2709}
2710impl<S: Simd> core::ops::BitAndAssign for i8x32<S> {
2711    #[doc = "Compute the bitwise AND of two vectors."]
2712    #[inline(always)]
2713    fn bitand_assign(&mut self, rhs: Self) {
2714        *self = self.simd.and_i8x32(*self, rhs);
2715    }
2716}
2717impl<S: Simd> core::ops::BitAnd<i8> for i8x32<S> {
2718    type Output = Self;
2719    #[inline(always)]
2720    fn bitand(self, rhs: i8) -> Self::Output {
2721        self.simd.and_i8x32(self, rhs.simd_into(self.simd))
2722    }
2723}
2724impl<S: Simd> core::ops::BitAndAssign<i8> for i8x32<S> {
2725    #[inline(always)]
2726    fn bitand_assign(&mut self, rhs: i8) {
2727        *self = self.simd.and_i8x32(*self, rhs.simd_into(self.simd));
2728    }
2729}
2730impl<S: Simd> core::ops::BitAnd<i8x32<S>> for i8 {
2731    type Output = i8x32<S>;
2732    #[inline(always)]
2733    fn bitand(self, rhs: i8x32<S>) -> Self::Output {
2734        rhs.simd.and_i8x32(self.simd_into(rhs.simd), rhs)
2735    }
2736}
2737impl<S: Simd> core::ops::BitOr for i8x32<S> {
2738    type Output = Self;
2739    #[doc = "Compute the bitwise OR of two vectors."]
2740    #[inline(always)]
2741    fn bitor(self, rhs: Self) -> Self::Output {
2742        self.simd.or_i8x32(self, rhs)
2743    }
2744}
2745impl<S: Simd> core::ops::BitOrAssign for i8x32<S> {
2746    #[doc = "Compute the bitwise OR of two vectors."]
2747    #[inline(always)]
2748    fn bitor_assign(&mut self, rhs: Self) {
2749        *self = self.simd.or_i8x32(*self, rhs);
2750    }
2751}
2752impl<S: Simd> core::ops::BitOr<i8> for i8x32<S> {
2753    type Output = Self;
2754    #[inline(always)]
2755    fn bitor(self, rhs: i8) -> Self::Output {
2756        self.simd.or_i8x32(self, rhs.simd_into(self.simd))
2757    }
2758}
2759impl<S: Simd> core::ops::BitOrAssign<i8> for i8x32<S> {
2760    #[inline(always)]
2761    fn bitor_assign(&mut self, rhs: i8) {
2762        *self = self.simd.or_i8x32(*self, rhs.simd_into(self.simd));
2763    }
2764}
2765impl<S: Simd> core::ops::BitOr<i8x32<S>> for i8 {
2766    type Output = i8x32<S>;
2767    #[inline(always)]
2768    fn bitor(self, rhs: i8x32<S>) -> Self::Output {
2769        rhs.simd.or_i8x32(self.simd_into(rhs.simd), rhs)
2770    }
2771}
2772impl<S: Simd> core::ops::BitXor for i8x32<S> {
2773    type Output = Self;
2774    #[doc = "Compute the bitwise XOR of two vectors."]
2775    #[inline(always)]
2776    fn bitxor(self, rhs: Self) -> Self::Output {
2777        self.simd.xor_i8x32(self, rhs)
2778    }
2779}
2780impl<S: Simd> core::ops::BitXorAssign for i8x32<S> {
2781    #[doc = "Compute the bitwise XOR of two vectors."]
2782    #[inline(always)]
2783    fn bitxor_assign(&mut self, rhs: Self) {
2784        *self = self.simd.xor_i8x32(*self, rhs);
2785    }
2786}
2787impl<S: Simd> core::ops::BitXor<i8> for i8x32<S> {
2788    type Output = Self;
2789    #[inline(always)]
2790    fn bitxor(self, rhs: i8) -> Self::Output {
2791        self.simd.xor_i8x32(self, rhs.simd_into(self.simd))
2792    }
2793}
2794impl<S: Simd> core::ops::BitXorAssign<i8> for i8x32<S> {
2795    #[inline(always)]
2796    fn bitxor_assign(&mut self, rhs: i8) {
2797        *self = self.simd.xor_i8x32(*self, rhs.simd_into(self.simd));
2798    }
2799}
2800impl<S: Simd> core::ops::BitXor<i8x32<S>> for i8 {
2801    type Output = i8x32<S>;
2802    #[inline(always)]
2803    fn bitxor(self, rhs: i8x32<S>) -> Self::Output {
2804        rhs.simd.xor_i8x32(self.simd_into(rhs.simd), rhs)
2805    }
2806}
2807impl<S: Simd> core::ops::Not for i8x32<S> {
2808    type Output = Self;
2809    #[doc = "Compute the bitwise NOT of the vector."]
2810    #[inline(always)]
2811    fn not(self) -> Self::Output {
2812        self.simd.not_i8x32(self)
2813    }
2814}
2815impl<S: Simd> core::ops::Shl<u32> for i8x32<S> {
2816    type Output = Self;
2817    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
2818    #[inline(always)]
2819    fn shl(self, rhs: u32) -> Self::Output {
2820        self.simd.shl_i8x32(self, rhs)
2821    }
2822}
2823impl<S: Simd> core::ops::ShlAssign<u32> for i8x32<S> {
2824    #[inline(always)]
2825    fn shl_assign(&mut self, rhs: u32) {
2826        *self = self.simd.shl_i8x32(*self, rhs);
2827    }
2828}
2829impl<S: Simd> core::ops::Shl for i8x32<S> {
2830    type Output = Self;
2831    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
2832    #[inline(always)]
2833    fn shl(self, rhs: Self) -> Self::Output {
2834        self.simd.shlv_i8x32(self, rhs)
2835    }
2836}
2837impl<S: Simd> core::ops::ShlAssign for i8x32<S> {
2838    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
2839    #[inline(always)]
2840    fn shl_assign(&mut self, rhs: Self) {
2841        *self = self.simd.shlv_i8x32(*self, rhs);
2842    }
2843}
2844impl<S: Simd> core::ops::Shr<u32> for i8x32<S> {
2845    type Output = Self;
2846    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
2847    #[inline(always)]
2848    fn shr(self, rhs: u32) -> Self::Output {
2849        self.simd.shr_i8x32(self, rhs)
2850    }
2851}
2852impl<S: Simd> core::ops::ShrAssign<u32> for i8x32<S> {
2853    #[inline(always)]
2854    fn shr_assign(&mut self, rhs: u32) {
2855        *self = self.simd.shr_i8x32(*self, rhs);
2856    }
2857}
2858impl<S: Simd> core::ops::Shr for i8x32<S> {
2859    type Output = Self;
2860    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
2861    #[inline(always)]
2862    fn shr(self, rhs: Self) -> Self::Output {
2863        self.simd.shrv_i8x32(self, rhs)
2864    }
2865}
2866impl<S: Simd> core::ops::ShrAssign for i8x32<S> {
2867    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
2868    #[inline(always)]
2869    fn shr_assign(&mut self, rhs: Self) {
2870        *self = self.simd.shrv_i8x32(*self, rhs);
2871    }
2872}
2873impl<S: Simd> core::ops::Add for u8x32<S> {
2874    type Output = Self;
2875    #[doc = "Add two vectors element-wise, wrapping on overflow."]
2876    #[inline(always)]
2877    fn add(self, rhs: Self) -> Self::Output {
2878        self.simd.add_u8x32(self, rhs)
2879    }
2880}
2881impl<S: Simd> core::ops::AddAssign for u8x32<S> {
2882    #[doc = "Add two vectors element-wise, wrapping on overflow."]
2883    #[inline(always)]
2884    fn add_assign(&mut self, rhs: Self) {
2885        *self = self.simd.add_u8x32(*self, rhs);
2886    }
2887}
2888impl<S: Simd> core::ops::Add<u8> for u8x32<S> {
2889    type Output = Self;
2890    #[inline(always)]
2891    fn add(self, rhs: u8) -> Self::Output {
2892        self.simd.add_u8x32(self, rhs.simd_into(self.simd))
2893    }
2894}
2895impl<S: Simd> core::ops::AddAssign<u8> for u8x32<S> {
2896    #[inline(always)]
2897    fn add_assign(&mut self, rhs: u8) {
2898        *self = self.simd.add_u8x32(*self, rhs.simd_into(self.simd));
2899    }
2900}
2901impl<S: Simd> core::ops::Add<u8x32<S>> for u8 {
2902    type Output = u8x32<S>;
2903    #[inline(always)]
2904    fn add(self, rhs: u8x32<S>) -> Self::Output {
2905        rhs.simd.add_u8x32(self.simd_into(rhs.simd), rhs)
2906    }
2907}
2908impl<S: Simd> core::ops::Sub for u8x32<S> {
2909    type Output = Self;
2910    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
2911    #[inline(always)]
2912    fn sub(self, rhs: Self) -> Self::Output {
2913        self.simd.sub_u8x32(self, rhs)
2914    }
2915}
2916impl<S: Simd> core::ops::SubAssign for u8x32<S> {
2917    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
2918    #[inline(always)]
2919    fn sub_assign(&mut self, rhs: Self) {
2920        *self = self.simd.sub_u8x32(*self, rhs);
2921    }
2922}
2923impl<S: Simd> core::ops::Sub<u8> for u8x32<S> {
2924    type Output = Self;
2925    #[inline(always)]
2926    fn sub(self, rhs: u8) -> Self::Output {
2927        self.simd.sub_u8x32(self, rhs.simd_into(self.simd))
2928    }
2929}
2930impl<S: Simd> core::ops::SubAssign<u8> for u8x32<S> {
2931    #[inline(always)]
2932    fn sub_assign(&mut self, rhs: u8) {
2933        *self = self.simd.sub_u8x32(*self, rhs.simd_into(self.simd));
2934    }
2935}
2936impl<S: Simd> core::ops::Sub<u8x32<S>> for u8 {
2937    type Output = u8x32<S>;
2938    #[inline(always)]
2939    fn sub(self, rhs: u8x32<S>) -> Self::Output {
2940        rhs.simd.sub_u8x32(self.simd_into(rhs.simd), rhs)
2941    }
2942}
2943impl<S: Simd> core::ops::Mul for u8x32<S> {
2944    type Output = Self;
2945    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
2946    #[inline(always)]
2947    fn mul(self, rhs: Self) -> Self::Output {
2948        self.simd.mul_u8x32(self, rhs)
2949    }
2950}
2951impl<S: Simd> core::ops::MulAssign for u8x32<S> {
2952    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
2953    #[inline(always)]
2954    fn mul_assign(&mut self, rhs: Self) {
2955        *self = self.simd.mul_u8x32(*self, rhs);
2956    }
2957}
2958impl<S: Simd> core::ops::Mul<u8> for u8x32<S> {
2959    type Output = Self;
2960    #[inline(always)]
2961    fn mul(self, rhs: u8) -> Self::Output {
2962        self.simd.mul_u8x32(self, rhs.simd_into(self.simd))
2963    }
2964}
2965impl<S: Simd> core::ops::MulAssign<u8> for u8x32<S> {
2966    #[inline(always)]
2967    fn mul_assign(&mut self, rhs: u8) {
2968        *self = self.simd.mul_u8x32(*self, rhs.simd_into(self.simd));
2969    }
2970}
2971impl<S: Simd> core::ops::Mul<u8x32<S>> for u8 {
2972    type Output = u8x32<S>;
2973    #[inline(always)]
2974    fn mul(self, rhs: u8x32<S>) -> Self::Output {
2975        rhs.simd.mul_u8x32(self.simd_into(rhs.simd), rhs)
2976    }
2977}
2978impl<S: Simd> core::ops::BitAnd for u8x32<S> {
2979    type Output = Self;
2980    #[doc = "Compute the bitwise AND of two vectors."]
2981    #[inline(always)]
2982    fn bitand(self, rhs: Self) -> Self::Output {
2983        self.simd.and_u8x32(self, rhs)
2984    }
2985}
2986impl<S: Simd> core::ops::BitAndAssign for u8x32<S> {
2987    #[doc = "Compute the bitwise AND of two vectors."]
2988    #[inline(always)]
2989    fn bitand_assign(&mut self, rhs: Self) {
2990        *self = self.simd.and_u8x32(*self, rhs);
2991    }
2992}
2993impl<S: Simd> core::ops::BitAnd<u8> for u8x32<S> {
2994    type Output = Self;
2995    #[inline(always)]
2996    fn bitand(self, rhs: u8) -> Self::Output {
2997        self.simd.and_u8x32(self, rhs.simd_into(self.simd))
2998    }
2999}
3000impl<S: Simd> core::ops::BitAndAssign<u8> for u8x32<S> {
3001    #[inline(always)]
3002    fn bitand_assign(&mut self, rhs: u8) {
3003        *self = self.simd.and_u8x32(*self, rhs.simd_into(self.simd));
3004    }
3005}
3006impl<S: Simd> core::ops::BitAnd<u8x32<S>> for u8 {
3007    type Output = u8x32<S>;
3008    #[inline(always)]
3009    fn bitand(self, rhs: u8x32<S>) -> Self::Output {
3010        rhs.simd.and_u8x32(self.simd_into(rhs.simd), rhs)
3011    }
3012}
3013impl<S: Simd> core::ops::BitOr for u8x32<S> {
3014    type Output = Self;
3015    #[doc = "Compute the bitwise OR of two vectors."]
3016    #[inline(always)]
3017    fn bitor(self, rhs: Self) -> Self::Output {
3018        self.simd.or_u8x32(self, rhs)
3019    }
3020}
3021impl<S: Simd> core::ops::BitOrAssign for u8x32<S> {
3022    #[doc = "Compute the bitwise OR of two vectors."]
3023    #[inline(always)]
3024    fn bitor_assign(&mut self, rhs: Self) {
3025        *self = self.simd.or_u8x32(*self, rhs);
3026    }
3027}
3028impl<S: Simd> core::ops::BitOr<u8> for u8x32<S> {
3029    type Output = Self;
3030    #[inline(always)]
3031    fn bitor(self, rhs: u8) -> Self::Output {
3032        self.simd.or_u8x32(self, rhs.simd_into(self.simd))
3033    }
3034}
3035impl<S: Simd> core::ops::BitOrAssign<u8> for u8x32<S> {
3036    #[inline(always)]
3037    fn bitor_assign(&mut self, rhs: u8) {
3038        *self = self.simd.or_u8x32(*self, rhs.simd_into(self.simd));
3039    }
3040}
3041impl<S: Simd> core::ops::BitOr<u8x32<S>> for u8 {
3042    type Output = u8x32<S>;
3043    #[inline(always)]
3044    fn bitor(self, rhs: u8x32<S>) -> Self::Output {
3045        rhs.simd.or_u8x32(self.simd_into(rhs.simd), rhs)
3046    }
3047}
3048impl<S: Simd> core::ops::BitXor for u8x32<S> {
3049    type Output = Self;
3050    #[doc = "Compute the bitwise XOR of two vectors."]
3051    #[inline(always)]
3052    fn bitxor(self, rhs: Self) -> Self::Output {
3053        self.simd.xor_u8x32(self, rhs)
3054    }
3055}
3056impl<S: Simd> core::ops::BitXorAssign for u8x32<S> {
3057    #[doc = "Compute the bitwise XOR of two vectors."]
3058    #[inline(always)]
3059    fn bitxor_assign(&mut self, rhs: Self) {
3060        *self = self.simd.xor_u8x32(*self, rhs);
3061    }
3062}
3063impl<S: Simd> core::ops::BitXor<u8> for u8x32<S> {
3064    type Output = Self;
3065    #[inline(always)]
3066    fn bitxor(self, rhs: u8) -> Self::Output {
3067        self.simd.xor_u8x32(self, rhs.simd_into(self.simd))
3068    }
3069}
3070impl<S: Simd> core::ops::BitXorAssign<u8> for u8x32<S> {
3071    #[inline(always)]
3072    fn bitxor_assign(&mut self, rhs: u8) {
3073        *self = self.simd.xor_u8x32(*self, rhs.simd_into(self.simd));
3074    }
3075}
3076impl<S: Simd> core::ops::BitXor<u8x32<S>> for u8 {
3077    type Output = u8x32<S>;
3078    #[inline(always)]
3079    fn bitxor(self, rhs: u8x32<S>) -> Self::Output {
3080        rhs.simd.xor_u8x32(self.simd_into(rhs.simd), rhs)
3081    }
3082}
3083impl<S: Simd> core::ops::Not for u8x32<S> {
3084    type Output = Self;
3085    #[doc = "Compute the bitwise NOT of the vector."]
3086    #[inline(always)]
3087    fn not(self) -> Self::Output {
3088        self.simd.not_u8x32(self)
3089    }
3090}
3091impl<S: Simd> core::ops::Shl<u32> for u8x32<S> {
3092    type Output = Self;
3093    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
3094    #[inline(always)]
3095    fn shl(self, rhs: u32) -> Self::Output {
3096        self.simd.shl_u8x32(self, rhs)
3097    }
3098}
3099impl<S: Simd> core::ops::ShlAssign<u32> for u8x32<S> {
3100    #[inline(always)]
3101    fn shl_assign(&mut self, rhs: u32) {
3102        *self = self.simd.shl_u8x32(*self, rhs);
3103    }
3104}
3105impl<S: Simd> core::ops::Shl for u8x32<S> {
3106    type Output = Self;
3107    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3108    #[inline(always)]
3109    fn shl(self, rhs: Self) -> Self::Output {
3110        self.simd.shlv_u8x32(self, rhs)
3111    }
3112}
3113impl<S: Simd> core::ops::ShlAssign for u8x32<S> {
3114    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3115    #[inline(always)]
3116    fn shl_assign(&mut self, rhs: Self) {
3117        *self = self.simd.shlv_u8x32(*self, rhs);
3118    }
3119}
3120impl<S: Simd> core::ops::Shr<u32> for u8x32<S> {
3121    type Output = Self;
3122    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
3123    #[inline(always)]
3124    fn shr(self, rhs: u32) -> Self::Output {
3125        self.simd.shr_u8x32(self, rhs)
3126    }
3127}
3128impl<S: Simd> core::ops::ShrAssign<u32> for u8x32<S> {
3129    #[inline(always)]
3130    fn shr_assign(&mut self, rhs: u32) {
3131        *self = self.simd.shr_u8x32(*self, rhs);
3132    }
3133}
3134impl<S: Simd> core::ops::Shr for u8x32<S> {
3135    type Output = Self;
3136    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3137    #[inline(always)]
3138    fn shr(self, rhs: Self) -> Self::Output {
3139        self.simd.shrv_u8x32(self, rhs)
3140    }
3141}
3142impl<S: Simd> core::ops::ShrAssign for u8x32<S> {
3143    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3144    #[inline(always)]
3145    fn shr_assign(&mut self, rhs: Self) {
3146        *self = self.simd.shrv_u8x32(*self, rhs);
3147    }
3148}
3149impl<S: Simd> core::ops::BitAnd for mask8x32<S> {
3150    type Output = Self;
3151    #[doc = "Compute the logical AND of two masks."]
3152    #[inline(always)]
3153    fn bitand(self, rhs: Self) -> Self::Output {
3154        self.simd.and_mask8x32(self, rhs)
3155    }
3156}
3157impl<S: Simd> core::ops::BitAndAssign for mask8x32<S> {
3158    #[doc = "Compute the logical AND of two masks."]
3159    #[inline(always)]
3160    fn bitand_assign(&mut self, rhs: Self) {
3161        *self = self.simd.and_mask8x32(*self, rhs);
3162    }
3163}
3164impl<S: Simd> core::ops::BitAnd<i8> for mask8x32<S> {
3165    type Output = Self;
3166    #[inline(always)]
3167    fn bitand(self, rhs: i8) -> Self::Output {
3168        self.simd.and_mask8x32(self, rhs.simd_into(self.simd))
3169    }
3170}
3171impl<S: Simd> core::ops::BitAndAssign<i8> for mask8x32<S> {
3172    #[inline(always)]
3173    fn bitand_assign(&mut self, rhs: i8) {
3174        *self = self.simd.and_mask8x32(*self, rhs.simd_into(self.simd));
3175    }
3176}
3177impl<S: Simd> core::ops::BitAnd<mask8x32<S>> for i8 {
3178    type Output = mask8x32<S>;
3179    #[inline(always)]
3180    fn bitand(self, rhs: mask8x32<S>) -> Self::Output {
3181        rhs.simd.and_mask8x32(self.simd_into(rhs.simd), rhs)
3182    }
3183}
3184impl<S: Simd> core::ops::BitOr for mask8x32<S> {
3185    type Output = Self;
3186    #[doc = "Compute the logical OR of two masks."]
3187    #[inline(always)]
3188    fn bitor(self, rhs: Self) -> Self::Output {
3189        self.simd.or_mask8x32(self, rhs)
3190    }
3191}
3192impl<S: Simd> core::ops::BitOrAssign for mask8x32<S> {
3193    #[doc = "Compute the logical OR of two masks."]
3194    #[inline(always)]
3195    fn bitor_assign(&mut self, rhs: Self) {
3196        *self = self.simd.or_mask8x32(*self, rhs);
3197    }
3198}
3199impl<S: Simd> core::ops::BitOr<i8> for mask8x32<S> {
3200    type Output = Self;
3201    #[inline(always)]
3202    fn bitor(self, rhs: i8) -> Self::Output {
3203        self.simd.or_mask8x32(self, rhs.simd_into(self.simd))
3204    }
3205}
3206impl<S: Simd> core::ops::BitOrAssign<i8> for mask8x32<S> {
3207    #[inline(always)]
3208    fn bitor_assign(&mut self, rhs: i8) {
3209        *self = self.simd.or_mask8x32(*self, rhs.simd_into(self.simd));
3210    }
3211}
3212impl<S: Simd> core::ops::BitOr<mask8x32<S>> for i8 {
3213    type Output = mask8x32<S>;
3214    #[inline(always)]
3215    fn bitor(self, rhs: mask8x32<S>) -> Self::Output {
3216        rhs.simd.or_mask8x32(self.simd_into(rhs.simd), rhs)
3217    }
3218}
3219impl<S: Simd> core::ops::BitXor for mask8x32<S> {
3220    type Output = Self;
3221    #[doc = "Compute the logical XOR of two masks."]
3222    #[inline(always)]
3223    fn bitxor(self, rhs: Self) -> Self::Output {
3224        self.simd.xor_mask8x32(self, rhs)
3225    }
3226}
3227impl<S: Simd> core::ops::BitXorAssign for mask8x32<S> {
3228    #[doc = "Compute the logical XOR of two masks."]
3229    #[inline(always)]
3230    fn bitxor_assign(&mut self, rhs: Self) {
3231        *self = self.simd.xor_mask8x32(*self, rhs);
3232    }
3233}
3234impl<S: Simd> core::ops::BitXor<i8> for mask8x32<S> {
3235    type Output = Self;
3236    #[inline(always)]
3237    fn bitxor(self, rhs: i8) -> Self::Output {
3238        self.simd.xor_mask8x32(self, rhs.simd_into(self.simd))
3239    }
3240}
3241impl<S: Simd> core::ops::BitXorAssign<i8> for mask8x32<S> {
3242    #[inline(always)]
3243    fn bitxor_assign(&mut self, rhs: i8) {
3244        *self = self.simd.xor_mask8x32(*self, rhs.simd_into(self.simd));
3245    }
3246}
3247impl<S: Simd> core::ops::BitXor<mask8x32<S>> for i8 {
3248    type Output = mask8x32<S>;
3249    #[inline(always)]
3250    fn bitxor(self, rhs: mask8x32<S>) -> Self::Output {
3251        rhs.simd.xor_mask8x32(self.simd_into(rhs.simd), rhs)
3252    }
3253}
3254impl<S: Simd> core::ops::Not for mask8x32<S> {
3255    type Output = Self;
3256    #[doc = "Compute the logical NOT of the mask."]
3257    #[inline(always)]
3258    fn not(self) -> Self::Output {
3259        self.simd.not_mask8x32(self)
3260    }
3261}
3262impl<S: Simd> core::ops::Neg for i16x16<S> {
3263    type Output = Self;
3264    #[doc = "Negate each element of the vector, wrapping on overflow."]
3265    #[inline(always)]
3266    fn neg(self) -> Self::Output {
3267        self.simd.neg_i16x16(self)
3268    }
3269}
3270impl<S: Simd> core::ops::Add for i16x16<S> {
3271    type Output = Self;
3272    #[doc = "Add two vectors element-wise, wrapping on overflow."]
3273    #[inline(always)]
3274    fn add(self, rhs: Self) -> Self::Output {
3275        self.simd.add_i16x16(self, rhs)
3276    }
3277}
3278impl<S: Simd> core::ops::AddAssign for i16x16<S> {
3279    #[doc = "Add two vectors element-wise, wrapping on overflow."]
3280    #[inline(always)]
3281    fn add_assign(&mut self, rhs: Self) {
3282        *self = self.simd.add_i16x16(*self, rhs);
3283    }
3284}
3285impl<S: Simd> core::ops::Add<i16> for i16x16<S> {
3286    type Output = Self;
3287    #[inline(always)]
3288    fn add(self, rhs: i16) -> Self::Output {
3289        self.simd.add_i16x16(self, rhs.simd_into(self.simd))
3290    }
3291}
3292impl<S: Simd> core::ops::AddAssign<i16> for i16x16<S> {
3293    #[inline(always)]
3294    fn add_assign(&mut self, rhs: i16) {
3295        *self = self.simd.add_i16x16(*self, rhs.simd_into(self.simd));
3296    }
3297}
3298impl<S: Simd> core::ops::Add<i16x16<S>> for i16 {
3299    type Output = i16x16<S>;
3300    #[inline(always)]
3301    fn add(self, rhs: i16x16<S>) -> Self::Output {
3302        rhs.simd.add_i16x16(self.simd_into(rhs.simd), rhs)
3303    }
3304}
3305impl<S: Simd> core::ops::Sub for i16x16<S> {
3306    type Output = Self;
3307    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
3308    #[inline(always)]
3309    fn sub(self, rhs: Self) -> Self::Output {
3310        self.simd.sub_i16x16(self, rhs)
3311    }
3312}
3313impl<S: Simd> core::ops::SubAssign for i16x16<S> {
3314    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
3315    #[inline(always)]
3316    fn sub_assign(&mut self, rhs: Self) {
3317        *self = self.simd.sub_i16x16(*self, rhs);
3318    }
3319}
3320impl<S: Simd> core::ops::Sub<i16> for i16x16<S> {
3321    type Output = Self;
3322    #[inline(always)]
3323    fn sub(self, rhs: i16) -> Self::Output {
3324        self.simd.sub_i16x16(self, rhs.simd_into(self.simd))
3325    }
3326}
3327impl<S: Simd> core::ops::SubAssign<i16> for i16x16<S> {
3328    #[inline(always)]
3329    fn sub_assign(&mut self, rhs: i16) {
3330        *self = self.simd.sub_i16x16(*self, rhs.simd_into(self.simd));
3331    }
3332}
3333impl<S: Simd> core::ops::Sub<i16x16<S>> for i16 {
3334    type Output = i16x16<S>;
3335    #[inline(always)]
3336    fn sub(self, rhs: i16x16<S>) -> Self::Output {
3337        rhs.simd.sub_i16x16(self.simd_into(rhs.simd), rhs)
3338    }
3339}
3340impl<S: Simd> core::ops::Mul for i16x16<S> {
3341    type Output = Self;
3342    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
3343    #[inline(always)]
3344    fn mul(self, rhs: Self) -> Self::Output {
3345        self.simd.mul_i16x16(self, rhs)
3346    }
3347}
3348impl<S: Simd> core::ops::MulAssign for i16x16<S> {
3349    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
3350    #[inline(always)]
3351    fn mul_assign(&mut self, rhs: Self) {
3352        *self = self.simd.mul_i16x16(*self, rhs);
3353    }
3354}
3355impl<S: Simd> core::ops::Mul<i16> for i16x16<S> {
3356    type Output = Self;
3357    #[inline(always)]
3358    fn mul(self, rhs: i16) -> Self::Output {
3359        self.simd.mul_i16x16(self, rhs.simd_into(self.simd))
3360    }
3361}
3362impl<S: Simd> core::ops::MulAssign<i16> for i16x16<S> {
3363    #[inline(always)]
3364    fn mul_assign(&mut self, rhs: i16) {
3365        *self = self.simd.mul_i16x16(*self, rhs.simd_into(self.simd));
3366    }
3367}
3368impl<S: Simd> core::ops::Mul<i16x16<S>> for i16 {
3369    type Output = i16x16<S>;
3370    #[inline(always)]
3371    fn mul(self, rhs: i16x16<S>) -> Self::Output {
3372        rhs.simd.mul_i16x16(self.simd_into(rhs.simd), rhs)
3373    }
3374}
3375impl<S: Simd> core::ops::BitAnd for i16x16<S> {
3376    type Output = Self;
3377    #[doc = "Compute the bitwise AND of two vectors."]
3378    #[inline(always)]
3379    fn bitand(self, rhs: Self) -> Self::Output {
3380        self.simd.and_i16x16(self, rhs)
3381    }
3382}
3383impl<S: Simd> core::ops::BitAndAssign for i16x16<S> {
3384    #[doc = "Compute the bitwise AND of two vectors."]
3385    #[inline(always)]
3386    fn bitand_assign(&mut self, rhs: Self) {
3387        *self = self.simd.and_i16x16(*self, rhs);
3388    }
3389}
3390impl<S: Simd> core::ops::BitAnd<i16> for i16x16<S> {
3391    type Output = Self;
3392    #[inline(always)]
3393    fn bitand(self, rhs: i16) -> Self::Output {
3394        self.simd.and_i16x16(self, rhs.simd_into(self.simd))
3395    }
3396}
3397impl<S: Simd> core::ops::BitAndAssign<i16> for i16x16<S> {
3398    #[inline(always)]
3399    fn bitand_assign(&mut self, rhs: i16) {
3400        *self = self.simd.and_i16x16(*self, rhs.simd_into(self.simd));
3401    }
3402}
3403impl<S: Simd> core::ops::BitAnd<i16x16<S>> for i16 {
3404    type Output = i16x16<S>;
3405    #[inline(always)]
3406    fn bitand(self, rhs: i16x16<S>) -> Self::Output {
3407        rhs.simd.and_i16x16(self.simd_into(rhs.simd), rhs)
3408    }
3409}
3410impl<S: Simd> core::ops::BitOr for i16x16<S> {
3411    type Output = Self;
3412    #[doc = "Compute the bitwise OR of two vectors."]
3413    #[inline(always)]
3414    fn bitor(self, rhs: Self) -> Self::Output {
3415        self.simd.or_i16x16(self, rhs)
3416    }
3417}
3418impl<S: Simd> core::ops::BitOrAssign for i16x16<S> {
3419    #[doc = "Compute the bitwise OR of two vectors."]
3420    #[inline(always)]
3421    fn bitor_assign(&mut self, rhs: Self) {
3422        *self = self.simd.or_i16x16(*self, rhs);
3423    }
3424}
3425impl<S: Simd> core::ops::BitOr<i16> for i16x16<S> {
3426    type Output = Self;
3427    #[inline(always)]
3428    fn bitor(self, rhs: i16) -> Self::Output {
3429        self.simd.or_i16x16(self, rhs.simd_into(self.simd))
3430    }
3431}
3432impl<S: Simd> core::ops::BitOrAssign<i16> for i16x16<S> {
3433    #[inline(always)]
3434    fn bitor_assign(&mut self, rhs: i16) {
3435        *self = self.simd.or_i16x16(*self, rhs.simd_into(self.simd));
3436    }
3437}
3438impl<S: Simd> core::ops::BitOr<i16x16<S>> for i16 {
3439    type Output = i16x16<S>;
3440    #[inline(always)]
3441    fn bitor(self, rhs: i16x16<S>) -> Self::Output {
3442        rhs.simd.or_i16x16(self.simd_into(rhs.simd), rhs)
3443    }
3444}
3445impl<S: Simd> core::ops::BitXor for i16x16<S> {
3446    type Output = Self;
3447    #[doc = "Compute the bitwise XOR of two vectors."]
3448    #[inline(always)]
3449    fn bitxor(self, rhs: Self) -> Self::Output {
3450        self.simd.xor_i16x16(self, rhs)
3451    }
3452}
3453impl<S: Simd> core::ops::BitXorAssign for i16x16<S> {
3454    #[doc = "Compute the bitwise XOR of two vectors."]
3455    #[inline(always)]
3456    fn bitxor_assign(&mut self, rhs: Self) {
3457        *self = self.simd.xor_i16x16(*self, rhs);
3458    }
3459}
3460impl<S: Simd> core::ops::BitXor<i16> for i16x16<S> {
3461    type Output = Self;
3462    #[inline(always)]
3463    fn bitxor(self, rhs: i16) -> Self::Output {
3464        self.simd.xor_i16x16(self, rhs.simd_into(self.simd))
3465    }
3466}
3467impl<S: Simd> core::ops::BitXorAssign<i16> for i16x16<S> {
3468    #[inline(always)]
3469    fn bitxor_assign(&mut self, rhs: i16) {
3470        *self = self.simd.xor_i16x16(*self, rhs.simd_into(self.simd));
3471    }
3472}
3473impl<S: Simd> core::ops::BitXor<i16x16<S>> for i16 {
3474    type Output = i16x16<S>;
3475    #[inline(always)]
3476    fn bitxor(self, rhs: i16x16<S>) -> Self::Output {
3477        rhs.simd.xor_i16x16(self.simd_into(rhs.simd), rhs)
3478    }
3479}
3480impl<S: Simd> core::ops::Not for i16x16<S> {
3481    type Output = Self;
3482    #[doc = "Compute the bitwise NOT of the vector."]
3483    #[inline(always)]
3484    fn not(self) -> Self::Output {
3485        self.simd.not_i16x16(self)
3486    }
3487}
3488impl<S: Simd> core::ops::Shl<u32> for i16x16<S> {
3489    type Output = Self;
3490    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
3491    #[inline(always)]
3492    fn shl(self, rhs: u32) -> Self::Output {
3493        self.simd.shl_i16x16(self, rhs)
3494    }
3495}
3496impl<S: Simd> core::ops::ShlAssign<u32> for i16x16<S> {
3497    #[inline(always)]
3498    fn shl_assign(&mut self, rhs: u32) {
3499        *self = self.simd.shl_i16x16(*self, rhs);
3500    }
3501}
3502impl<S: Simd> core::ops::Shl for i16x16<S> {
3503    type Output = Self;
3504    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3505    #[inline(always)]
3506    fn shl(self, rhs: Self) -> Self::Output {
3507        self.simd.shlv_i16x16(self, rhs)
3508    }
3509}
3510impl<S: Simd> core::ops::ShlAssign for i16x16<S> {
3511    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3512    #[inline(always)]
3513    fn shl_assign(&mut self, rhs: Self) {
3514        *self = self.simd.shlv_i16x16(*self, rhs);
3515    }
3516}
3517impl<S: Simd> core::ops::Shr<u32> for i16x16<S> {
3518    type Output = Self;
3519    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
3520    #[inline(always)]
3521    fn shr(self, rhs: u32) -> Self::Output {
3522        self.simd.shr_i16x16(self, rhs)
3523    }
3524}
3525impl<S: Simd> core::ops::ShrAssign<u32> for i16x16<S> {
3526    #[inline(always)]
3527    fn shr_assign(&mut self, rhs: u32) {
3528        *self = self.simd.shr_i16x16(*self, rhs);
3529    }
3530}
3531impl<S: Simd> core::ops::Shr for i16x16<S> {
3532    type Output = Self;
3533    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3534    #[inline(always)]
3535    fn shr(self, rhs: Self) -> Self::Output {
3536        self.simd.shrv_i16x16(self, rhs)
3537    }
3538}
3539impl<S: Simd> core::ops::ShrAssign for i16x16<S> {
3540    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3541    #[inline(always)]
3542    fn shr_assign(&mut self, rhs: Self) {
3543        *self = self.simd.shrv_i16x16(*self, rhs);
3544    }
3545}
3546impl<S: Simd> core::ops::Add for u16x16<S> {
3547    type Output = Self;
3548    #[doc = "Add two vectors element-wise, wrapping on overflow."]
3549    #[inline(always)]
3550    fn add(self, rhs: Self) -> Self::Output {
3551        self.simd.add_u16x16(self, rhs)
3552    }
3553}
3554impl<S: Simd> core::ops::AddAssign for u16x16<S> {
3555    #[doc = "Add two vectors element-wise, wrapping on overflow."]
3556    #[inline(always)]
3557    fn add_assign(&mut self, rhs: Self) {
3558        *self = self.simd.add_u16x16(*self, rhs);
3559    }
3560}
3561impl<S: Simd> core::ops::Add<u16> for u16x16<S> {
3562    type Output = Self;
3563    #[inline(always)]
3564    fn add(self, rhs: u16) -> Self::Output {
3565        self.simd.add_u16x16(self, rhs.simd_into(self.simd))
3566    }
3567}
3568impl<S: Simd> core::ops::AddAssign<u16> for u16x16<S> {
3569    #[inline(always)]
3570    fn add_assign(&mut self, rhs: u16) {
3571        *self = self.simd.add_u16x16(*self, rhs.simd_into(self.simd));
3572    }
3573}
3574impl<S: Simd> core::ops::Add<u16x16<S>> for u16 {
3575    type Output = u16x16<S>;
3576    #[inline(always)]
3577    fn add(self, rhs: u16x16<S>) -> Self::Output {
3578        rhs.simd.add_u16x16(self.simd_into(rhs.simd), rhs)
3579    }
3580}
3581impl<S: Simd> core::ops::Sub for u16x16<S> {
3582    type Output = Self;
3583    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
3584    #[inline(always)]
3585    fn sub(self, rhs: Self) -> Self::Output {
3586        self.simd.sub_u16x16(self, rhs)
3587    }
3588}
3589impl<S: Simd> core::ops::SubAssign for u16x16<S> {
3590    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
3591    #[inline(always)]
3592    fn sub_assign(&mut self, rhs: Self) {
3593        *self = self.simd.sub_u16x16(*self, rhs);
3594    }
3595}
3596impl<S: Simd> core::ops::Sub<u16> for u16x16<S> {
3597    type Output = Self;
3598    #[inline(always)]
3599    fn sub(self, rhs: u16) -> Self::Output {
3600        self.simd.sub_u16x16(self, rhs.simd_into(self.simd))
3601    }
3602}
3603impl<S: Simd> core::ops::SubAssign<u16> for u16x16<S> {
3604    #[inline(always)]
3605    fn sub_assign(&mut self, rhs: u16) {
3606        *self = self.simd.sub_u16x16(*self, rhs.simd_into(self.simd));
3607    }
3608}
3609impl<S: Simd> core::ops::Sub<u16x16<S>> for u16 {
3610    type Output = u16x16<S>;
3611    #[inline(always)]
3612    fn sub(self, rhs: u16x16<S>) -> Self::Output {
3613        rhs.simd.sub_u16x16(self.simd_into(rhs.simd), rhs)
3614    }
3615}
3616impl<S: Simd> core::ops::Mul for u16x16<S> {
3617    type Output = Self;
3618    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
3619    #[inline(always)]
3620    fn mul(self, rhs: Self) -> Self::Output {
3621        self.simd.mul_u16x16(self, rhs)
3622    }
3623}
3624impl<S: Simd> core::ops::MulAssign for u16x16<S> {
3625    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
3626    #[inline(always)]
3627    fn mul_assign(&mut self, rhs: Self) {
3628        *self = self.simd.mul_u16x16(*self, rhs);
3629    }
3630}
3631impl<S: Simd> core::ops::Mul<u16> for u16x16<S> {
3632    type Output = Self;
3633    #[inline(always)]
3634    fn mul(self, rhs: u16) -> Self::Output {
3635        self.simd.mul_u16x16(self, rhs.simd_into(self.simd))
3636    }
3637}
3638impl<S: Simd> core::ops::MulAssign<u16> for u16x16<S> {
3639    #[inline(always)]
3640    fn mul_assign(&mut self, rhs: u16) {
3641        *self = self.simd.mul_u16x16(*self, rhs.simd_into(self.simd));
3642    }
3643}
3644impl<S: Simd> core::ops::Mul<u16x16<S>> for u16 {
3645    type Output = u16x16<S>;
3646    #[inline(always)]
3647    fn mul(self, rhs: u16x16<S>) -> Self::Output {
3648        rhs.simd.mul_u16x16(self.simd_into(rhs.simd), rhs)
3649    }
3650}
3651impl<S: Simd> core::ops::BitAnd for u16x16<S> {
3652    type Output = Self;
3653    #[doc = "Compute the bitwise AND of two vectors."]
3654    #[inline(always)]
3655    fn bitand(self, rhs: Self) -> Self::Output {
3656        self.simd.and_u16x16(self, rhs)
3657    }
3658}
3659impl<S: Simd> core::ops::BitAndAssign for u16x16<S> {
3660    #[doc = "Compute the bitwise AND of two vectors."]
3661    #[inline(always)]
3662    fn bitand_assign(&mut self, rhs: Self) {
3663        *self = self.simd.and_u16x16(*self, rhs);
3664    }
3665}
3666impl<S: Simd> core::ops::BitAnd<u16> for u16x16<S> {
3667    type Output = Self;
3668    #[inline(always)]
3669    fn bitand(self, rhs: u16) -> Self::Output {
3670        self.simd.and_u16x16(self, rhs.simd_into(self.simd))
3671    }
3672}
3673impl<S: Simd> core::ops::BitAndAssign<u16> for u16x16<S> {
3674    #[inline(always)]
3675    fn bitand_assign(&mut self, rhs: u16) {
3676        *self = self.simd.and_u16x16(*self, rhs.simd_into(self.simd));
3677    }
3678}
3679impl<S: Simd> core::ops::BitAnd<u16x16<S>> for u16 {
3680    type Output = u16x16<S>;
3681    #[inline(always)]
3682    fn bitand(self, rhs: u16x16<S>) -> Self::Output {
3683        rhs.simd.and_u16x16(self.simd_into(rhs.simd), rhs)
3684    }
3685}
3686impl<S: Simd> core::ops::BitOr for u16x16<S> {
3687    type Output = Self;
3688    #[doc = "Compute the bitwise OR of two vectors."]
3689    #[inline(always)]
3690    fn bitor(self, rhs: Self) -> Self::Output {
3691        self.simd.or_u16x16(self, rhs)
3692    }
3693}
3694impl<S: Simd> core::ops::BitOrAssign for u16x16<S> {
3695    #[doc = "Compute the bitwise OR of two vectors."]
3696    #[inline(always)]
3697    fn bitor_assign(&mut self, rhs: Self) {
3698        *self = self.simd.or_u16x16(*self, rhs);
3699    }
3700}
3701impl<S: Simd> core::ops::BitOr<u16> for u16x16<S> {
3702    type Output = Self;
3703    #[inline(always)]
3704    fn bitor(self, rhs: u16) -> Self::Output {
3705        self.simd.or_u16x16(self, rhs.simd_into(self.simd))
3706    }
3707}
3708impl<S: Simd> core::ops::BitOrAssign<u16> for u16x16<S> {
3709    #[inline(always)]
3710    fn bitor_assign(&mut self, rhs: u16) {
3711        *self = self.simd.or_u16x16(*self, rhs.simd_into(self.simd));
3712    }
3713}
3714impl<S: Simd> core::ops::BitOr<u16x16<S>> for u16 {
3715    type Output = u16x16<S>;
3716    #[inline(always)]
3717    fn bitor(self, rhs: u16x16<S>) -> Self::Output {
3718        rhs.simd.or_u16x16(self.simd_into(rhs.simd), rhs)
3719    }
3720}
3721impl<S: Simd> core::ops::BitXor for u16x16<S> {
3722    type Output = Self;
3723    #[doc = "Compute the bitwise XOR of two vectors."]
3724    #[inline(always)]
3725    fn bitxor(self, rhs: Self) -> Self::Output {
3726        self.simd.xor_u16x16(self, rhs)
3727    }
3728}
3729impl<S: Simd> core::ops::BitXorAssign for u16x16<S> {
3730    #[doc = "Compute the bitwise XOR of two vectors."]
3731    #[inline(always)]
3732    fn bitxor_assign(&mut self, rhs: Self) {
3733        *self = self.simd.xor_u16x16(*self, rhs);
3734    }
3735}
3736impl<S: Simd> core::ops::BitXor<u16> for u16x16<S> {
3737    type Output = Self;
3738    #[inline(always)]
3739    fn bitxor(self, rhs: u16) -> Self::Output {
3740        self.simd.xor_u16x16(self, rhs.simd_into(self.simd))
3741    }
3742}
3743impl<S: Simd> core::ops::BitXorAssign<u16> for u16x16<S> {
3744    #[inline(always)]
3745    fn bitxor_assign(&mut self, rhs: u16) {
3746        *self = self.simd.xor_u16x16(*self, rhs.simd_into(self.simd));
3747    }
3748}
3749impl<S: Simd> core::ops::BitXor<u16x16<S>> for u16 {
3750    type Output = u16x16<S>;
3751    #[inline(always)]
3752    fn bitxor(self, rhs: u16x16<S>) -> Self::Output {
3753        rhs.simd.xor_u16x16(self.simd_into(rhs.simd), rhs)
3754    }
3755}
3756impl<S: Simd> core::ops::Not for u16x16<S> {
3757    type Output = Self;
3758    #[doc = "Compute the bitwise NOT of the vector."]
3759    #[inline(always)]
3760    fn not(self) -> Self::Output {
3761        self.simd.not_u16x16(self)
3762    }
3763}
3764impl<S: Simd> core::ops::Shl<u32> for u16x16<S> {
3765    type Output = Self;
3766    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
3767    #[inline(always)]
3768    fn shl(self, rhs: u32) -> Self::Output {
3769        self.simd.shl_u16x16(self, rhs)
3770    }
3771}
3772impl<S: Simd> core::ops::ShlAssign<u32> for u16x16<S> {
3773    #[inline(always)]
3774    fn shl_assign(&mut self, rhs: u32) {
3775        *self = self.simd.shl_u16x16(*self, rhs);
3776    }
3777}
3778impl<S: Simd> core::ops::Shl for u16x16<S> {
3779    type Output = Self;
3780    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3781    #[inline(always)]
3782    fn shl(self, rhs: Self) -> Self::Output {
3783        self.simd.shlv_u16x16(self, rhs)
3784    }
3785}
3786impl<S: Simd> core::ops::ShlAssign for u16x16<S> {
3787    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3788    #[inline(always)]
3789    fn shl_assign(&mut self, rhs: Self) {
3790        *self = self.simd.shlv_u16x16(*self, rhs);
3791    }
3792}
3793impl<S: Simd> core::ops::Shr<u32> for u16x16<S> {
3794    type Output = Self;
3795    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
3796    #[inline(always)]
3797    fn shr(self, rhs: u32) -> Self::Output {
3798        self.simd.shr_u16x16(self, rhs)
3799    }
3800}
3801impl<S: Simd> core::ops::ShrAssign<u32> for u16x16<S> {
3802    #[inline(always)]
3803    fn shr_assign(&mut self, rhs: u32) {
3804        *self = self.simd.shr_u16x16(*self, rhs);
3805    }
3806}
3807impl<S: Simd> core::ops::Shr for u16x16<S> {
3808    type Output = Self;
3809    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3810    #[inline(always)]
3811    fn shr(self, rhs: Self) -> Self::Output {
3812        self.simd.shrv_u16x16(self, rhs)
3813    }
3814}
3815impl<S: Simd> core::ops::ShrAssign for u16x16<S> {
3816    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
3817    #[inline(always)]
3818    fn shr_assign(&mut self, rhs: Self) {
3819        *self = self.simd.shrv_u16x16(*self, rhs);
3820    }
3821}
3822impl<S: Simd> core::ops::BitAnd for mask16x16<S> {
3823    type Output = Self;
3824    #[doc = "Compute the logical AND of two masks."]
3825    #[inline(always)]
3826    fn bitand(self, rhs: Self) -> Self::Output {
3827        self.simd.and_mask16x16(self, rhs)
3828    }
3829}
3830impl<S: Simd> core::ops::BitAndAssign for mask16x16<S> {
3831    #[doc = "Compute the logical AND of two masks."]
3832    #[inline(always)]
3833    fn bitand_assign(&mut self, rhs: Self) {
3834        *self = self.simd.and_mask16x16(*self, rhs);
3835    }
3836}
3837impl<S: Simd> core::ops::BitAnd<i16> for mask16x16<S> {
3838    type Output = Self;
3839    #[inline(always)]
3840    fn bitand(self, rhs: i16) -> Self::Output {
3841        self.simd.and_mask16x16(self, rhs.simd_into(self.simd))
3842    }
3843}
3844impl<S: Simd> core::ops::BitAndAssign<i16> for mask16x16<S> {
3845    #[inline(always)]
3846    fn bitand_assign(&mut self, rhs: i16) {
3847        *self = self.simd.and_mask16x16(*self, rhs.simd_into(self.simd));
3848    }
3849}
3850impl<S: Simd> core::ops::BitAnd<mask16x16<S>> for i16 {
3851    type Output = mask16x16<S>;
3852    #[inline(always)]
3853    fn bitand(self, rhs: mask16x16<S>) -> Self::Output {
3854        rhs.simd.and_mask16x16(self.simd_into(rhs.simd), rhs)
3855    }
3856}
3857impl<S: Simd> core::ops::BitOr for mask16x16<S> {
3858    type Output = Self;
3859    #[doc = "Compute the logical OR of two masks."]
3860    #[inline(always)]
3861    fn bitor(self, rhs: Self) -> Self::Output {
3862        self.simd.or_mask16x16(self, rhs)
3863    }
3864}
3865impl<S: Simd> core::ops::BitOrAssign for mask16x16<S> {
3866    #[doc = "Compute the logical OR of two masks."]
3867    #[inline(always)]
3868    fn bitor_assign(&mut self, rhs: Self) {
3869        *self = self.simd.or_mask16x16(*self, rhs);
3870    }
3871}
3872impl<S: Simd> core::ops::BitOr<i16> for mask16x16<S> {
3873    type Output = Self;
3874    #[inline(always)]
3875    fn bitor(self, rhs: i16) -> Self::Output {
3876        self.simd.or_mask16x16(self, rhs.simd_into(self.simd))
3877    }
3878}
3879impl<S: Simd> core::ops::BitOrAssign<i16> for mask16x16<S> {
3880    #[inline(always)]
3881    fn bitor_assign(&mut self, rhs: i16) {
3882        *self = self.simd.or_mask16x16(*self, rhs.simd_into(self.simd));
3883    }
3884}
3885impl<S: Simd> core::ops::BitOr<mask16x16<S>> for i16 {
3886    type Output = mask16x16<S>;
3887    #[inline(always)]
3888    fn bitor(self, rhs: mask16x16<S>) -> Self::Output {
3889        rhs.simd.or_mask16x16(self.simd_into(rhs.simd), rhs)
3890    }
3891}
3892impl<S: Simd> core::ops::BitXor for mask16x16<S> {
3893    type Output = Self;
3894    #[doc = "Compute the logical XOR of two masks."]
3895    #[inline(always)]
3896    fn bitxor(self, rhs: Self) -> Self::Output {
3897        self.simd.xor_mask16x16(self, rhs)
3898    }
3899}
3900impl<S: Simd> core::ops::BitXorAssign for mask16x16<S> {
3901    #[doc = "Compute the logical XOR of two masks."]
3902    #[inline(always)]
3903    fn bitxor_assign(&mut self, rhs: Self) {
3904        *self = self.simd.xor_mask16x16(*self, rhs);
3905    }
3906}
3907impl<S: Simd> core::ops::BitXor<i16> for mask16x16<S> {
3908    type Output = Self;
3909    #[inline(always)]
3910    fn bitxor(self, rhs: i16) -> Self::Output {
3911        self.simd.xor_mask16x16(self, rhs.simd_into(self.simd))
3912    }
3913}
3914impl<S: Simd> core::ops::BitXorAssign<i16> for mask16x16<S> {
3915    #[inline(always)]
3916    fn bitxor_assign(&mut self, rhs: i16) {
3917        *self = self.simd.xor_mask16x16(*self, rhs.simd_into(self.simd));
3918    }
3919}
3920impl<S: Simd> core::ops::BitXor<mask16x16<S>> for i16 {
3921    type Output = mask16x16<S>;
3922    #[inline(always)]
3923    fn bitxor(self, rhs: mask16x16<S>) -> Self::Output {
3924        rhs.simd.xor_mask16x16(self.simd_into(rhs.simd), rhs)
3925    }
3926}
3927impl<S: Simd> core::ops::Not for mask16x16<S> {
3928    type Output = Self;
3929    #[doc = "Compute the logical NOT of the mask."]
3930    #[inline(always)]
3931    fn not(self) -> Self::Output {
3932        self.simd.not_mask16x16(self)
3933    }
3934}
3935impl<S: Simd> core::ops::Neg for i32x8<S> {
3936    type Output = Self;
3937    #[doc = "Negate each element of the vector, wrapping on overflow."]
3938    #[inline(always)]
3939    fn neg(self) -> Self::Output {
3940        self.simd.neg_i32x8(self)
3941    }
3942}
3943impl<S: Simd> core::ops::Add for i32x8<S> {
3944    type Output = Self;
3945    #[doc = "Add two vectors element-wise, wrapping on overflow."]
3946    #[inline(always)]
3947    fn add(self, rhs: Self) -> Self::Output {
3948        self.simd.add_i32x8(self, rhs)
3949    }
3950}
3951impl<S: Simd> core::ops::AddAssign for i32x8<S> {
3952    #[doc = "Add two vectors element-wise, wrapping on overflow."]
3953    #[inline(always)]
3954    fn add_assign(&mut self, rhs: Self) {
3955        *self = self.simd.add_i32x8(*self, rhs);
3956    }
3957}
3958impl<S: Simd> core::ops::Add<i32> for i32x8<S> {
3959    type Output = Self;
3960    #[inline(always)]
3961    fn add(self, rhs: i32) -> Self::Output {
3962        self.simd.add_i32x8(self, rhs.simd_into(self.simd))
3963    }
3964}
3965impl<S: Simd> core::ops::AddAssign<i32> for i32x8<S> {
3966    #[inline(always)]
3967    fn add_assign(&mut self, rhs: i32) {
3968        *self = self.simd.add_i32x8(*self, rhs.simd_into(self.simd));
3969    }
3970}
3971impl<S: Simd> core::ops::Add<i32x8<S>> for i32 {
3972    type Output = i32x8<S>;
3973    #[inline(always)]
3974    fn add(self, rhs: i32x8<S>) -> Self::Output {
3975        rhs.simd.add_i32x8(self.simd_into(rhs.simd), rhs)
3976    }
3977}
3978impl<S: Simd> core::ops::Sub for i32x8<S> {
3979    type Output = Self;
3980    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
3981    #[inline(always)]
3982    fn sub(self, rhs: Self) -> Self::Output {
3983        self.simd.sub_i32x8(self, rhs)
3984    }
3985}
3986impl<S: Simd> core::ops::SubAssign for i32x8<S> {
3987    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
3988    #[inline(always)]
3989    fn sub_assign(&mut self, rhs: Self) {
3990        *self = self.simd.sub_i32x8(*self, rhs);
3991    }
3992}
3993impl<S: Simd> core::ops::Sub<i32> for i32x8<S> {
3994    type Output = Self;
3995    #[inline(always)]
3996    fn sub(self, rhs: i32) -> Self::Output {
3997        self.simd.sub_i32x8(self, rhs.simd_into(self.simd))
3998    }
3999}
4000impl<S: Simd> core::ops::SubAssign<i32> for i32x8<S> {
4001    #[inline(always)]
4002    fn sub_assign(&mut self, rhs: i32) {
4003        *self = self.simd.sub_i32x8(*self, rhs.simd_into(self.simd));
4004    }
4005}
4006impl<S: Simd> core::ops::Sub<i32x8<S>> for i32 {
4007    type Output = i32x8<S>;
4008    #[inline(always)]
4009    fn sub(self, rhs: i32x8<S>) -> Self::Output {
4010        rhs.simd.sub_i32x8(self.simd_into(rhs.simd), rhs)
4011    }
4012}
4013impl<S: Simd> core::ops::Mul for i32x8<S> {
4014    type Output = Self;
4015    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
4016    #[inline(always)]
4017    fn mul(self, rhs: Self) -> Self::Output {
4018        self.simd.mul_i32x8(self, rhs)
4019    }
4020}
4021impl<S: Simd> core::ops::MulAssign for i32x8<S> {
4022    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
4023    #[inline(always)]
4024    fn mul_assign(&mut self, rhs: Self) {
4025        *self = self.simd.mul_i32x8(*self, rhs);
4026    }
4027}
4028impl<S: Simd> core::ops::Mul<i32> for i32x8<S> {
4029    type Output = Self;
4030    #[inline(always)]
4031    fn mul(self, rhs: i32) -> Self::Output {
4032        self.simd.mul_i32x8(self, rhs.simd_into(self.simd))
4033    }
4034}
4035impl<S: Simd> core::ops::MulAssign<i32> for i32x8<S> {
4036    #[inline(always)]
4037    fn mul_assign(&mut self, rhs: i32) {
4038        *self = self.simd.mul_i32x8(*self, rhs.simd_into(self.simd));
4039    }
4040}
4041impl<S: Simd> core::ops::Mul<i32x8<S>> for i32 {
4042    type Output = i32x8<S>;
4043    #[inline(always)]
4044    fn mul(self, rhs: i32x8<S>) -> Self::Output {
4045        rhs.simd.mul_i32x8(self.simd_into(rhs.simd), rhs)
4046    }
4047}
4048impl<S: Simd> core::ops::BitAnd for i32x8<S> {
4049    type Output = Self;
4050    #[doc = "Compute the bitwise AND of two vectors."]
4051    #[inline(always)]
4052    fn bitand(self, rhs: Self) -> Self::Output {
4053        self.simd.and_i32x8(self, rhs)
4054    }
4055}
4056impl<S: Simd> core::ops::BitAndAssign for i32x8<S> {
4057    #[doc = "Compute the bitwise AND of two vectors."]
4058    #[inline(always)]
4059    fn bitand_assign(&mut self, rhs: Self) {
4060        *self = self.simd.and_i32x8(*self, rhs);
4061    }
4062}
4063impl<S: Simd> core::ops::BitAnd<i32> for i32x8<S> {
4064    type Output = Self;
4065    #[inline(always)]
4066    fn bitand(self, rhs: i32) -> Self::Output {
4067        self.simd.and_i32x8(self, rhs.simd_into(self.simd))
4068    }
4069}
4070impl<S: Simd> core::ops::BitAndAssign<i32> for i32x8<S> {
4071    #[inline(always)]
4072    fn bitand_assign(&mut self, rhs: i32) {
4073        *self = self.simd.and_i32x8(*self, rhs.simd_into(self.simd));
4074    }
4075}
4076impl<S: Simd> core::ops::BitAnd<i32x8<S>> for i32 {
4077    type Output = i32x8<S>;
4078    #[inline(always)]
4079    fn bitand(self, rhs: i32x8<S>) -> Self::Output {
4080        rhs.simd.and_i32x8(self.simd_into(rhs.simd), rhs)
4081    }
4082}
4083impl<S: Simd> core::ops::BitOr for i32x8<S> {
4084    type Output = Self;
4085    #[doc = "Compute the bitwise OR of two vectors."]
4086    #[inline(always)]
4087    fn bitor(self, rhs: Self) -> Self::Output {
4088        self.simd.or_i32x8(self, rhs)
4089    }
4090}
4091impl<S: Simd> core::ops::BitOrAssign for i32x8<S> {
4092    #[doc = "Compute the bitwise OR of two vectors."]
4093    #[inline(always)]
4094    fn bitor_assign(&mut self, rhs: Self) {
4095        *self = self.simd.or_i32x8(*self, rhs);
4096    }
4097}
4098impl<S: Simd> core::ops::BitOr<i32> for i32x8<S> {
4099    type Output = Self;
4100    #[inline(always)]
4101    fn bitor(self, rhs: i32) -> Self::Output {
4102        self.simd.or_i32x8(self, rhs.simd_into(self.simd))
4103    }
4104}
4105impl<S: Simd> core::ops::BitOrAssign<i32> for i32x8<S> {
4106    #[inline(always)]
4107    fn bitor_assign(&mut self, rhs: i32) {
4108        *self = self.simd.or_i32x8(*self, rhs.simd_into(self.simd));
4109    }
4110}
4111impl<S: Simd> core::ops::BitOr<i32x8<S>> for i32 {
4112    type Output = i32x8<S>;
4113    #[inline(always)]
4114    fn bitor(self, rhs: i32x8<S>) -> Self::Output {
4115        rhs.simd.or_i32x8(self.simd_into(rhs.simd), rhs)
4116    }
4117}
4118impl<S: Simd> core::ops::BitXor for i32x8<S> {
4119    type Output = Self;
4120    #[doc = "Compute the bitwise XOR of two vectors."]
4121    #[inline(always)]
4122    fn bitxor(self, rhs: Self) -> Self::Output {
4123        self.simd.xor_i32x8(self, rhs)
4124    }
4125}
4126impl<S: Simd> core::ops::BitXorAssign for i32x8<S> {
4127    #[doc = "Compute the bitwise XOR of two vectors."]
4128    #[inline(always)]
4129    fn bitxor_assign(&mut self, rhs: Self) {
4130        *self = self.simd.xor_i32x8(*self, rhs);
4131    }
4132}
4133impl<S: Simd> core::ops::BitXor<i32> for i32x8<S> {
4134    type Output = Self;
4135    #[inline(always)]
4136    fn bitxor(self, rhs: i32) -> Self::Output {
4137        self.simd.xor_i32x8(self, rhs.simd_into(self.simd))
4138    }
4139}
4140impl<S: Simd> core::ops::BitXorAssign<i32> for i32x8<S> {
4141    #[inline(always)]
4142    fn bitxor_assign(&mut self, rhs: i32) {
4143        *self = self.simd.xor_i32x8(*self, rhs.simd_into(self.simd));
4144    }
4145}
4146impl<S: Simd> core::ops::BitXor<i32x8<S>> for i32 {
4147    type Output = i32x8<S>;
4148    #[inline(always)]
4149    fn bitxor(self, rhs: i32x8<S>) -> Self::Output {
4150        rhs.simd.xor_i32x8(self.simd_into(rhs.simd), rhs)
4151    }
4152}
4153impl<S: Simd> core::ops::Not for i32x8<S> {
4154    type Output = Self;
4155    #[doc = "Compute the bitwise NOT of the vector."]
4156    #[inline(always)]
4157    fn not(self) -> Self::Output {
4158        self.simd.not_i32x8(self)
4159    }
4160}
4161impl<S: Simd> core::ops::Shl<u32> for i32x8<S> {
4162    type Output = Self;
4163    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
4164    #[inline(always)]
4165    fn shl(self, rhs: u32) -> Self::Output {
4166        self.simd.shl_i32x8(self, rhs)
4167    }
4168}
4169impl<S: Simd> core::ops::ShlAssign<u32> for i32x8<S> {
4170    #[inline(always)]
4171    fn shl_assign(&mut self, rhs: u32) {
4172        *self = self.simd.shl_i32x8(*self, rhs);
4173    }
4174}
4175impl<S: Simd> core::ops::Shl for i32x8<S> {
4176    type Output = Self;
4177    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
4178    #[inline(always)]
4179    fn shl(self, rhs: Self) -> Self::Output {
4180        self.simd.shlv_i32x8(self, rhs)
4181    }
4182}
4183impl<S: Simd> core::ops::ShlAssign for i32x8<S> {
4184    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
4185    #[inline(always)]
4186    fn shl_assign(&mut self, rhs: Self) {
4187        *self = self.simd.shlv_i32x8(*self, rhs);
4188    }
4189}
4190impl<S: Simd> core::ops::Shr<u32> for i32x8<S> {
4191    type Output = Self;
4192    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
4193    #[inline(always)]
4194    fn shr(self, rhs: u32) -> Self::Output {
4195        self.simd.shr_i32x8(self, rhs)
4196    }
4197}
4198impl<S: Simd> core::ops::ShrAssign<u32> for i32x8<S> {
4199    #[inline(always)]
4200    fn shr_assign(&mut self, rhs: u32) {
4201        *self = self.simd.shr_i32x8(*self, rhs);
4202    }
4203}
4204impl<S: Simd> core::ops::Shr for i32x8<S> {
4205    type Output = Self;
4206    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
4207    #[inline(always)]
4208    fn shr(self, rhs: Self) -> Self::Output {
4209        self.simd.shrv_i32x8(self, rhs)
4210    }
4211}
4212impl<S: Simd> core::ops::ShrAssign for i32x8<S> {
4213    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
4214    #[inline(always)]
4215    fn shr_assign(&mut self, rhs: Self) {
4216        *self = self.simd.shrv_i32x8(*self, rhs);
4217    }
4218}
4219impl<S: Simd> core::ops::Add for u32x8<S> {
4220    type Output = Self;
4221    #[doc = "Add two vectors element-wise, wrapping on overflow."]
4222    #[inline(always)]
4223    fn add(self, rhs: Self) -> Self::Output {
4224        self.simd.add_u32x8(self, rhs)
4225    }
4226}
4227impl<S: Simd> core::ops::AddAssign for u32x8<S> {
4228    #[doc = "Add two vectors element-wise, wrapping on overflow."]
4229    #[inline(always)]
4230    fn add_assign(&mut self, rhs: Self) {
4231        *self = self.simd.add_u32x8(*self, rhs);
4232    }
4233}
4234impl<S: Simd> core::ops::Add<u32> for u32x8<S> {
4235    type Output = Self;
4236    #[inline(always)]
4237    fn add(self, rhs: u32) -> Self::Output {
4238        self.simd.add_u32x8(self, rhs.simd_into(self.simd))
4239    }
4240}
4241impl<S: Simd> core::ops::AddAssign<u32> for u32x8<S> {
4242    #[inline(always)]
4243    fn add_assign(&mut self, rhs: u32) {
4244        *self = self.simd.add_u32x8(*self, rhs.simd_into(self.simd));
4245    }
4246}
4247impl<S: Simd> core::ops::Add<u32x8<S>> for u32 {
4248    type Output = u32x8<S>;
4249    #[inline(always)]
4250    fn add(self, rhs: u32x8<S>) -> Self::Output {
4251        rhs.simd.add_u32x8(self.simd_into(rhs.simd), rhs)
4252    }
4253}
4254impl<S: Simd> core::ops::Sub for u32x8<S> {
4255    type Output = Self;
4256    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
4257    #[inline(always)]
4258    fn sub(self, rhs: Self) -> Self::Output {
4259        self.simd.sub_u32x8(self, rhs)
4260    }
4261}
4262impl<S: Simd> core::ops::SubAssign for u32x8<S> {
4263    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
4264    #[inline(always)]
4265    fn sub_assign(&mut self, rhs: Self) {
4266        *self = self.simd.sub_u32x8(*self, rhs);
4267    }
4268}
4269impl<S: Simd> core::ops::Sub<u32> for u32x8<S> {
4270    type Output = Self;
4271    #[inline(always)]
4272    fn sub(self, rhs: u32) -> Self::Output {
4273        self.simd.sub_u32x8(self, rhs.simd_into(self.simd))
4274    }
4275}
4276impl<S: Simd> core::ops::SubAssign<u32> for u32x8<S> {
4277    #[inline(always)]
4278    fn sub_assign(&mut self, rhs: u32) {
4279        *self = self.simd.sub_u32x8(*self, rhs.simd_into(self.simd));
4280    }
4281}
4282impl<S: Simd> core::ops::Sub<u32x8<S>> for u32 {
4283    type Output = u32x8<S>;
4284    #[inline(always)]
4285    fn sub(self, rhs: u32x8<S>) -> Self::Output {
4286        rhs.simd.sub_u32x8(self.simd_into(rhs.simd), rhs)
4287    }
4288}
4289impl<S: Simd> core::ops::Mul for u32x8<S> {
4290    type Output = Self;
4291    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
4292    #[inline(always)]
4293    fn mul(self, rhs: Self) -> Self::Output {
4294        self.simd.mul_u32x8(self, rhs)
4295    }
4296}
4297impl<S: Simd> core::ops::MulAssign for u32x8<S> {
4298    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
4299    #[inline(always)]
4300    fn mul_assign(&mut self, rhs: Self) {
4301        *self = self.simd.mul_u32x8(*self, rhs);
4302    }
4303}
4304impl<S: Simd> core::ops::Mul<u32> for u32x8<S> {
4305    type Output = Self;
4306    #[inline(always)]
4307    fn mul(self, rhs: u32) -> Self::Output {
4308        self.simd.mul_u32x8(self, rhs.simd_into(self.simd))
4309    }
4310}
4311impl<S: Simd> core::ops::MulAssign<u32> for u32x8<S> {
4312    #[inline(always)]
4313    fn mul_assign(&mut self, rhs: u32) {
4314        *self = self.simd.mul_u32x8(*self, rhs.simd_into(self.simd));
4315    }
4316}
4317impl<S: Simd> core::ops::Mul<u32x8<S>> for u32 {
4318    type Output = u32x8<S>;
4319    #[inline(always)]
4320    fn mul(self, rhs: u32x8<S>) -> Self::Output {
4321        rhs.simd.mul_u32x8(self.simd_into(rhs.simd), rhs)
4322    }
4323}
4324impl<S: Simd> core::ops::BitAnd for u32x8<S> {
4325    type Output = Self;
4326    #[doc = "Compute the bitwise AND of two vectors."]
4327    #[inline(always)]
4328    fn bitand(self, rhs: Self) -> Self::Output {
4329        self.simd.and_u32x8(self, rhs)
4330    }
4331}
4332impl<S: Simd> core::ops::BitAndAssign for u32x8<S> {
4333    #[doc = "Compute the bitwise AND of two vectors."]
4334    #[inline(always)]
4335    fn bitand_assign(&mut self, rhs: Self) {
4336        *self = self.simd.and_u32x8(*self, rhs);
4337    }
4338}
4339impl<S: Simd> core::ops::BitAnd<u32> for u32x8<S> {
4340    type Output = Self;
4341    #[inline(always)]
4342    fn bitand(self, rhs: u32) -> Self::Output {
4343        self.simd.and_u32x8(self, rhs.simd_into(self.simd))
4344    }
4345}
4346impl<S: Simd> core::ops::BitAndAssign<u32> for u32x8<S> {
4347    #[inline(always)]
4348    fn bitand_assign(&mut self, rhs: u32) {
4349        *self = self.simd.and_u32x8(*self, rhs.simd_into(self.simd));
4350    }
4351}
4352impl<S: Simd> core::ops::BitAnd<u32x8<S>> for u32 {
4353    type Output = u32x8<S>;
4354    #[inline(always)]
4355    fn bitand(self, rhs: u32x8<S>) -> Self::Output {
4356        rhs.simd.and_u32x8(self.simd_into(rhs.simd), rhs)
4357    }
4358}
4359impl<S: Simd> core::ops::BitOr for u32x8<S> {
4360    type Output = Self;
4361    #[doc = "Compute the bitwise OR of two vectors."]
4362    #[inline(always)]
4363    fn bitor(self, rhs: Self) -> Self::Output {
4364        self.simd.or_u32x8(self, rhs)
4365    }
4366}
4367impl<S: Simd> core::ops::BitOrAssign for u32x8<S> {
4368    #[doc = "Compute the bitwise OR of two vectors."]
4369    #[inline(always)]
4370    fn bitor_assign(&mut self, rhs: Self) {
4371        *self = self.simd.or_u32x8(*self, rhs);
4372    }
4373}
4374impl<S: Simd> core::ops::BitOr<u32> for u32x8<S> {
4375    type Output = Self;
4376    #[inline(always)]
4377    fn bitor(self, rhs: u32) -> Self::Output {
4378        self.simd.or_u32x8(self, rhs.simd_into(self.simd))
4379    }
4380}
4381impl<S: Simd> core::ops::BitOrAssign<u32> for u32x8<S> {
4382    #[inline(always)]
4383    fn bitor_assign(&mut self, rhs: u32) {
4384        *self = self.simd.or_u32x8(*self, rhs.simd_into(self.simd));
4385    }
4386}
4387impl<S: Simd> core::ops::BitOr<u32x8<S>> for u32 {
4388    type Output = u32x8<S>;
4389    #[inline(always)]
4390    fn bitor(self, rhs: u32x8<S>) -> Self::Output {
4391        rhs.simd.or_u32x8(self.simd_into(rhs.simd), rhs)
4392    }
4393}
4394impl<S: Simd> core::ops::BitXor for u32x8<S> {
4395    type Output = Self;
4396    #[doc = "Compute the bitwise XOR of two vectors."]
4397    #[inline(always)]
4398    fn bitxor(self, rhs: Self) -> Self::Output {
4399        self.simd.xor_u32x8(self, rhs)
4400    }
4401}
4402impl<S: Simd> core::ops::BitXorAssign for u32x8<S> {
4403    #[doc = "Compute the bitwise XOR of two vectors."]
4404    #[inline(always)]
4405    fn bitxor_assign(&mut self, rhs: Self) {
4406        *self = self.simd.xor_u32x8(*self, rhs);
4407    }
4408}
4409impl<S: Simd> core::ops::BitXor<u32> for u32x8<S> {
4410    type Output = Self;
4411    #[inline(always)]
4412    fn bitxor(self, rhs: u32) -> Self::Output {
4413        self.simd.xor_u32x8(self, rhs.simd_into(self.simd))
4414    }
4415}
4416impl<S: Simd> core::ops::BitXorAssign<u32> for u32x8<S> {
4417    #[inline(always)]
4418    fn bitxor_assign(&mut self, rhs: u32) {
4419        *self = self.simd.xor_u32x8(*self, rhs.simd_into(self.simd));
4420    }
4421}
4422impl<S: Simd> core::ops::BitXor<u32x8<S>> for u32 {
4423    type Output = u32x8<S>;
4424    #[inline(always)]
4425    fn bitxor(self, rhs: u32x8<S>) -> Self::Output {
4426        rhs.simd.xor_u32x8(self.simd_into(rhs.simd), rhs)
4427    }
4428}
4429impl<S: Simd> core::ops::Not for u32x8<S> {
4430    type Output = Self;
4431    #[doc = "Compute the bitwise NOT of the vector."]
4432    #[inline(always)]
4433    fn not(self) -> Self::Output {
4434        self.simd.not_u32x8(self)
4435    }
4436}
4437impl<S: Simd> core::ops::Shl<u32> for u32x8<S> {
4438    type Output = Self;
4439    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
4440    #[inline(always)]
4441    fn shl(self, rhs: u32) -> Self::Output {
4442        self.simd.shl_u32x8(self, rhs)
4443    }
4444}
4445impl<S: Simd> core::ops::ShlAssign<u32> for u32x8<S> {
4446    #[inline(always)]
4447    fn shl_assign(&mut self, rhs: u32) {
4448        *self = self.simd.shl_u32x8(*self, rhs);
4449    }
4450}
4451impl<S: Simd> core::ops::Shl for u32x8<S> {
4452    type Output = Self;
4453    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
4454    #[inline(always)]
4455    fn shl(self, rhs: Self) -> Self::Output {
4456        self.simd.shlv_u32x8(self, rhs)
4457    }
4458}
4459impl<S: Simd> core::ops::ShlAssign for u32x8<S> {
4460    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
4461    #[inline(always)]
4462    fn shl_assign(&mut self, rhs: Self) {
4463        *self = self.simd.shlv_u32x8(*self, rhs);
4464    }
4465}
4466impl<S: Simd> core::ops::Shr<u32> for u32x8<S> {
4467    type Output = Self;
4468    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
4469    #[inline(always)]
4470    fn shr(self, rhs: u32) -> Self::Output {
4471        self.simd.shr_u32x8(self, rhs)
4472    }
4473}
4474impl<S: Simd> core::ops::ShrAssign<u32> for u32x8<S> {
4475    #[inline(always)]
4476    fn shr_assign(&mut self, rhs: u32) {
4477        *self = self.simd.shr_u32x8(*self, rhs);
4478    }
4479}
4480impl<S: Simd> core::ops::Shr for u32x8<S> {
4481    type Output = Self;
4482    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
4483    #[inline(always)]
4484    fn shr(self, rhs: Self) -> Self::Output {
4485        self.simd.shrv_u32x8(self, rhs)
4486    }
4487}
4488impl<S: Simd> core::ops::ShrAssign for u32x8<S> {
4489    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
4490    #[inline(always)]
4491    fn shr_assign(&mut self, rhs: Self) {
4492        *self = self.simd.shrv_u32x8(*self, rhs);
4493    }
4494}
4495impl<S: Simd> core::ops::BitAnd for mask32x8<S> {
4496    type Output = Self;
4497    #[doc = "Compute the logical AND of two masks."]
4498    #[inline(always)]
4499    fn bitand(self, rhs: Self) -> Self::Output {
4500        self.simd.and_mask32x8(self, rhs)
4501    }
4502}
4503impl<S: Simd> core::ops::BitAndAssign for mask32x8<S> {
4504    #[doc = "Compute the logical AND of two masks."]
4505    #[inline(always)]
4506    fn bitand_assign(&mut self, rhs: Self) {
4507        *self = self.simd.and_mask32x8(*self, rhs);
4508    }
4509}
4510impl<S: Simd> core::ops::BitAnd<i32> for mask32x8<S> {
4511    type Output = Self;
4512    #[inline(always)]
4513    fn bitand(self, rhs: i32) -> Self::Output {
4514        self.simd.and_mask32x8(self, rhs.simd_into(self.simd))
4515    }
4516}
4517impl<S: Simd> core::ops::BitAndAssign<i32> for mask32x8<S> {
4518    #[inline(always)]
4519    fn bitand_assign(&mut self, rhs: i32) {
4520        *self = self.simd.and_mask32x8(*self, rhs.simd_into(self.simd));
4521    }
4522}
4523impl<S: Simd> core::ops::BitAnd<mask32x8<S>> for i32 {
4524    type Output = mask32x8<S>;
4525    #[inline(always)]
4526    fn bitand(self, rhs: mask32x8<S>) -> Self::Output {
4527        rhs.simd.and_mask32x8(self.simd_into(rhs.simd), rhs)
4528    }
4529}
4530impl<S: Simd> core::ops::BitOr for mask32x8<S> {
4531    type Output = Self;
4532    #[doc = "Compute the logical OR of two masks."]
4533    #[inline(always)]
4534    fn bitor(self, rhs: Self) -> Self::Output {
4535        self.simd.or_mask32x8(self, rhs)
4536    }
4537}
4538impl<S: Simd> core::ops::BitOrAssign for mask32x8<S> {
4539    #[doc = "Compute the logical OR of two masks."]
4540    #[inline(always)]
4541    fn bitor_assign(&mut self, rhs: Self) {
4542        *self = self.simd.or_mask32x8(*self, rhs);
4543    }
4544}
4545impl<S: Simd> core::ops::BitOr<i32> for mask32x8<S> {
4546    type Output = Self;
4547    #[inline(always)]
4548    fn bitor(self, rhs: i32) -> Self::Output {
4549        self.simd.or_mask32x8(self, rhs.simd_into(self.simd))
4550    }
4551}
4552impl<S: Simd> core::ops::BitOrAssign<i32> for mask32x8<S> {
4553    #[inline(always)]
4554    fn bitor_assign(&mut self, rhs: i32) {
4555        *self = self.simd.or_mask32x8(*self, rhs.simd_into(self.simd));
4556    }
4557}
4558impl<S: Simd> core::ops::BitOr<mask32x8<S>> for i32 {
4559    type Output = mask32x8<S>;
4560    #[inline(always)]
4561    fn bitor(self, rhs: mask32x8<S>) -> Self::Output {
4562        rhs.simd.or_mask32x8(self.simd_into(rhs.simd), rhs)
4563    }
4564}
4565impl<S: Simd> core::ops::BitXor for mask32x8<S> {
4566    type Output = Self;
4567    #[doc = "Compute the logical XOR of two masks."]
4568    #[inline(always)]
4569    fn bitxor(self, rhs: Self) -> Self::Output {
4570        self.simd.xor_mask32x8(self, rhs)
4571    }
4572}
4573impl<S: Simd> core::ops::BitXorAssign for mask32x8<S> {
4574    #[doc = "Compute the logical XOR of two masks."]
4575    #[inline(always)]
4576    fn bitxor_assign(&mut self, rhs: Self) {
4577        *self = self.simd.xor_mask32x8(*self, rhs);
4578    }
4579}
4580impl<S: Simd> core::ops::BitXor<i32> for mask32x8<S> {
4581    type Output = Self;
4582    #[inline(always)]
4583    fn bitxor(self, rhs: i32) -> Self::Output {
4584        self.simd.xor_mask32x8(self, rhs.simd_into(self.simd))
4585    }
4586}
4587impl<S: Simd> core::ops::BitXorAssign<i32> for mask32x8<S> {
4588    #[inline(always)]
4589    fn bitxor_assign(&mut self, rhs: i32) {
4590        *self = self.simd.xor_mask32x8(*self, rhs.simd_into(self.simd));
4591    }
4592}
4593impl<S: Simd> core::ops::BitXor<mask32x8<S>> for i32 {
4594    type Output = mask32x8<S>;
4595    #[inline(always)]
4596    fn bitxor(self, rhs: mask32x8<S>) -> Self::Output {
4597        rhs.simd.xor_mask32x8(self.simd_into(rhs.simd), rhs)
4598    }
4599}
4600impl<S: Simd> core::ops::Not for mask32x8<S> {
4601    type Output = Self;
4602    #[doc = "Compute the logical NOT of the mask."]
4603    #[inline(always)]
4604    fn not(self) -> Self::Output {
4605        self.simd.not_mask32x8(self)
4606    }
4607}
4608impl<S: Simd> core::ops::Neg for f64x4<S> {
4609    type Output = Self;
4610    #[doc = "Negate each element of the vector."]
4611    #[inline(always)]
4612    fn neg(self) -> Self::Output {
4613        self.simd.neg_f64x4(self)
4614    }
4615}
4616impl<S: Simd> core::ops::Add for f64x4<S> {
4617    type Output = Self;
4618    #[doc = "Add two vectors element-wise."]
4619    #[inline(always)]
4620    fn add(self, rhs: Self) -> Self::Output {
4621        self.simd.add_f64x4(self, rhs)
4622    }
4623}
4624impl<S: Simd> core::ops::AddAssign for f64x4<S> {
4625    #[doc = "Add two vectors element-wise."]
4626    #[inline(always)]
4627    fn add_assign(&mut self, rhs: Self) {
4628        *self = self.simd.add_f64x4(*self, rhs);
4629    }
4630}
4631impl<S: Simd> core::ops::Add<f64> for f64x4<S> {
4632    type Output = Self;
4633    #[inline(always)]
4634    fn add(self, rhs: f64) -> Self::Output {
4635        self.simd.add_f64x4(self, rhs.simd_into(self.simd))
4636    }
4637}
4638impl<S: Simd> core::ops::AddAssign<f64> for f64x4<S> {
4639    #[inline(always)]
4640    fn add_assign(&mut self, rhs: f64) {
4641        *self = self.simd.add_f64x4(*self, rhs.simd_into(self.simd));
4642    }
4643}
4644impl<S: Simd> core::ops::Add<f64x4<S>> for f64 {
4645    type Output = f64x4<S>;
4646    #[inline(always)]
4647    fn add(self, rhs: f64x4<S>) -> Self::Output {
4648        rhs.simd.add_f64x4(self.simd_into(rhs.simd), rhs)
4649    }
4650}
4651impl<S: Simd> core::ops::Sub for f64x4<S> {
4652    type Output = Self;
4653    #[doc = "Subtract two vectors element-wise."]
4654    #[inline(always)]
4655    fn sub(self, rhs: Self) -> Self::Output {
4656        self.simd.sub_f64x4(self, rhs)
4657    }
4658}
4659impl<S: Simd> core::ops::SubAssign for f64x4<S> {
4660    #[doc = "Subtract two vectors element-wise."]
4661    #[inline(always)]
4662    fn sub_assign(&mut self, rhs: Self) {
4663        *self = self.simd.sub_f64x4(*self, rhs);
4664    }
4665}
4666impl<S: Simd> core::ops::Sub<f64> for f64x4<S> {
4667    type Output = Self;
4668    #[inline(always)]
4669    fn sub(self, rhs: f64) -> Self::Output {
4670        self.simd.sub_f64x4(self, rhs.simd_into(self.simd))
4671    }
4672}
4673impl<S: Simd> core::ops::SubAssign<f64> for f64x4<S> {
4674    #[inline(always)]
4675    fn sub_assign(&mut self, rhs: f64) {
4676        *self = self.simd.sub_f64x4(*self, rhs.simd_into(self.simd));
4677    }
4678}
4679impl<S: Simd> core::ops::Sub<f64x4<S>> for f64 {
4680    type Output = f64x4<S>;
4681    #[inline(always)]
4682    fn sub(self, rhs: f64x4<S>) -> Self::Output {
4683        rhs.simd.sub_f64x4(self.simd_into(rhs.simd), rhs)
4684    }
4685}
4686impl<S: Simd> core::ops::Mul for f64x4<S> {
4687    type Output = Self;
4688    #[doc = "Multiply two vectors element-wise."]
4689    #[inline(always)]
4690    fn mul(self, rhs: Self) -> Self::Output {
4691        self.simd.mul_f64x4(self, rhs)
4692    }
4693}
4694impl<S: Simd> core::ops::MulAssign for f64x4<S> {
4695    #[doc = "Multiply two vectors element-wise."]
4696    #[inline(always)]
4697    fn mul_assign(&mut self, rhs: Self) {
4698        *self = self.simd.mul_f64x4(*self, rhs);
4699    }
4700}
4701impl<S: Simd> core::ops::Mul<f64> for f64x4<S> {
4702    type Output = Self;
4703    #[inline(always)]
4704    fn mul(self, rhs: f64) -> Self::Output {
4705        self.simd.mul_f64x4(self, rhs.simd_into(self.simd))
4706    }
4707}
4708impl<S: Simd> core::ops::MulAssign<f64> for f64x4<S> {
4709    #[inline(always)]
4710    fn mul_assign(&mut self, rhs: f64) {
4711        *self = self.simd.mul_f64x4(*self, rhs.simd_into(self.simd));
4712    }
4713}
4714impl<S: Simd> core::ops::Mul<f64x4<S>> for f64 {
4715    type Output = f64x4<S>;
4716    #[inline(always)]
4717    fn mul(self, rhs: f64x4<S>) -> Self::Output {
4718        rhs.simd.mul_f64x4(self.simd_into(rhs.simd), rhs)
4719    }
4720}
4721impl<S: Simd> core::ops::Div for f64x4<S> {
4722    type Output = Self;
4723    #[doc = "Divide two vectors element-wise."]
4724    #[inline(always)]
4725    fn div(self, rhs: Self) -> Self::Output {
4726        self.simd.div_f64x4(self, rhs)
4727    }
4728}
4729impl<S: Simd> core::ops::DivAssign for f64x4<S> {
4730    #[doc = "Divide two vectors element-wise."]
4731    #[inline(always)]
4732    fn div_assign(&mut self, rhs: Self) {
4733        *self = self.simd.div_f64x4(*self, rhs);
4734    }
4735}
4736impl<S: Simd> core::ops::Div<f64> for f64x4<S> {
4737    type Output = Self;
4738    #[inline(always)]
4739    fn div(self, rhs: f64) -> Self::Output {
4740        self.simd.div_f64x4(self, rhs.simd_into(self.simd))
4741    }
4742}
4743impl<S: Simd> core::ops::DivAssign<f64> for f64x4<S> {
4744    #[inline(always)]
4745    fn div_assign(&mut self, rhs: f64) {
4746        *self = self.simd.div_f64x4(*self, rhs.simd_into(self.simd));
4747    }
4748}
4749impl<S: Simd> core::ops::Div<f64x4<S>> for f64 {
4750    type Output = f64x4<S>;
4751    #[inline(always)]
4752    fn div(self, rhs: f64x4<S>) -> Self::Output {
4753        rhs.simd.div_f64x4(self.simd_into(rhs.simd), rhs)
4754    }
4755}
4756impl<S: Simd> core::ops::BitAnd for mask64x4<S> {
4757    type Output = Self;
4758    #[doc = "Compute the logical AND of two masks."]
4759    #[inline(always)]
4760    fn bitand(self, rhs: Self) -> Self::Output {
4761        self.simd.and_mask64x4(self, rhs)
4762    }
4763}
4764impl<S: Simd> core::ops::BitAndAssign for mask64x4<S> {
4765    #[doc = "Compute the logical AND of two masks."]
4766    #[inline(always)]
4767    fn bitand_assign(&mut self, rhs: Self) {
4768        *self = self.simd.and_mask64x4(*self, rhs);
4769    }
4770}
4771impl<S: Simd> core::ops::BitAnd<i64> for mask64x4<S> {
4772    type Output = Self;
4773    #[inline(always)]
4774    fn bitand(self, rhs: i64) -> Self::Output {
4775        self.simd.and_mask64x4(self, rhs.simd_into(self.simd))
4776    }
4777}
4778impl<S: Simd> core::ops::BitAndAssign<i64> for mask64x4<S> {
4779    #[inline(always)]
4780    fn bitand_assign(&mut self, rhs: i64) {
4781        *self = self.simd.and_mask64x4(*self, rhs.simd_into(self.simd));
4782    }
4783}
4784impl<S: Simd> core::ops::BitAnd<mask64x4<S>> for i64 {
4785    type Output = mask64x4<S>;
4786    #[inline(always)]
4787    fn bitand(self, rhs: mask64x4<S>) -> Self::Output {
4788        rhs.simd.and_mask64x4(self.simd_into(rhs.simd), rhs)
4789    }
4790}
4791impl<S: Simd> core::ops::BitOr for mask64x4<S> {
4792    type Output = Self;
4793    #[doc = "Compute the logical OR of two masks."]
4794    #[inline(always)]
4795    fn bitor(self, rhs: Self) -> Self::Output {
4796        self.simd.or_mask64x4(self, rhs)
4797    }
4798}
4799impl<S: Simd> core::ops::BitOrAssign for mask64x4<S> {
4800    #[doc = "Compute the logical OR of two masks."]
4801    #[inline(always)]
4802    fn bitor_assign(&mut self, rhs: Self) {
4803        *self = self.simd.or_mask64x4(*self, rhs);
4804    }
4805}
4806impl<S: Simd> core::ops::BitOr<i64> for mask64x4<S> {
4807    type Output = Self;
4808    #[inline(always)]
4809    fn bitor(self, rhs: i64) -> Self::Output {
4810        self.simd.or_mask64x4(self, rhs.simd_into(self.simd))
4811    }
4812}
4813impl<S: Simd> core::ops::BitOrAssign<i64> for mask64x4<S> {
4814    #[inline(always)]
4815    fn bitor_assign(&mut self, rhs: i64) {
4816        *self = self.simd.or_mask64x4(*self, rhs.simd_into(self.simd));
4817    }
4818}
4819impl<S: Simd> core::ops::BitOr<mask64x4<S>> for i64 {
4820    type Output = mask64x4<S>;
4821    #[inline(always)]
4822    fn bitor(self, rhs: mask64x4<S>) -> Self::Output {
4823        rhs.simd.or_mask64x4(self.simd_into(rhs.simd), rhs)
4824    }
4825}
4826impl<S: Simd> core::ops::BitXor for mask64x4<S> {
4827    type Output = Self;
4828    #[doc = "Compute the logical XOR of two masks."]
4829    #[inline(always)]
4830    fn bitxor(self, rhs: Self) -> Self::Output {
4831        self.simd.xor_mask64x4(self, rhs)
4832    }
4833}
4834impl<S: Simd> core::ops::BitXorAssign for mask64x4<S> {
4835    #[doc = "Compute the logical XOR of two masks."]
4836    #[inline(always)]
4837    fn bitxor_assign(&mut self, rhs: Self) {
4838        *self = self.simd.xor_mask64x4(*self, rhs);
4839    }
4840}
4841impl<S: Simd> core::ops::BitXor<i64> for mask64x4<S> {
4842    type Output = Self;
4843    #[inline(always)]
4844    fn bitxor(self, rhs: i64) -> Self::Output {
4845        self.simd.xor_mask64x4(self, rhs.simd_into(self.simd))
4846    }
4847}
4848impl<S: Simd> core::ops::BitXorAssign<i64> for mask64x4<S> {
4849    #[inline(always)]
4850    fn bitxor_assign(&mut self, rhs: i64) {
4851        *self = self.simd.xor_mask64x4(*self, rhs.simd_into(self.simd));
4852    }
4853}
4854impl<S: Simd> core::ops::BitXor<mask64x4<S>> for i64 {
4855    type Output = mask64x4<S>;
4856    #[inline(always)]
4857    fn bitxor(self, rhs: mask64x4<S>) -> Self::Output {
4858        rhs.simd.xor_mask64x4(self.simd_into(rhs.simd), rhs)
4859    }
4860}
4861impl<S: Simd> core::ops::Not for mask64x4<S> {
4862    type Output = Self;
4863    #[doc = "Compute the logical NOT of the mask."]
4864    #[inline(always)]
4865    fn not(self) -> Self::Output {
4866        self.simd.not_mask64x4(self)
4867    }
4868}
4869impl<S: Simd> core::ops::Neg for f32x16<S> {
4870    type Output = Self;
4871    #[doc = "Negate each element of the vector."]
4872    #[inline(always)]
4873    fn neg(self) -> Self::Output {
4874        self.simd.neg_f32x16(self)
4875    }
4876}
4877impl<S: Simd> core::ops::Add for f32x16<S> {
4878    type Output = Self;
4879    #[doc = "Add two vectors element-wise."]
4880    #[inline(always)]
4881    fn add(self, rhs: Self) -> Self::Output {
4882        self.simd.add_f32x16(self, rhs)
4883    }
4884}
4885impl<S: Simd> core::ops::AddAssign for f32x16<S> {
4886    #[doc = "Add two vectors element-wise."]
4887    #[inline(always)]
4888    fn add_assign(&mut self, rhs: Self) {
4889        *self = self.simd.add_f32x16(*self, rhs);
4890    }
4891}
4892impl<S: Simd> core::ops::Add<f32> for f32x16<S> {
4893    type Output = Self;
4894    #[inline(always)]
4895    fn add(self, rhs: f32) -> Self::Output {
4896        self.simd.add_f32x16(self, rhs.simd_into(self.simd))
4897    }
4898}
4899impl<S: Simd> core::ops::AddAssign<f32> for f32x16<S> {
4900    #[inline(always)]
4901    fn add_assign(&mut self, rhs: f32) {
4902        *self = self.simd.add_f32x16(*self, rhs.simd_into(self.simd));
4903    }
4904}
4905impl<S: Simd> core::ops::Add<f32x16<S>> for f32 {
4906    type Output = f32x16<S>;
4907    #[inline(always)]
4908    fn add(self, rhs: f32x16<S>) -> Self::Output {
4909        rhs.simd.add_f32x16(self.simd_into(rhs.simd), rhs)
4910    }
4911}
4912impl<S: Simd> core::ops::Sub for f32x16<S> {
4913    type Output = Self;
4914    #[doc = "Subtract two vectors element-wise."]
4915    #[inline(always)]
4916    fn sub(self, rhs: Self) -> Self::Output {
4917        self.simd.sub_f32x16(self, rhs)
4918    }
4919}
4920impl<S: Simd> core::ops::SubAssign for f32x16<S> {
4921    #[doc = "Subtract two vectors element-wise."]
4922    #[inline(always)]
4923    fn sub_assign(&mut self, rhs: Self) {
4924        *self = self.simd.sub_f32x16(*self, rhs);
4925    }
4926}
4927impl<S: Simd> core::ops::Sub<f32> for f32x16<S> {
4928    type Output = Self;
4929    #[inline(always)]
4930    fn sub(self, rhs: f32) -> Self::Output {
4931        self.simd.sub_f32x16(self, rhs.simd_into(self.simd))
4932    }
4933}
4934impl<S: Simd> core::ops::SubAssign<f32> for f32x16<S> {
4935    #[inline(always)]
4936    fn sub_assign(&mut self, rhs: f32) {
4937        *self = self.simd.sub_f32x16(*self, rhs.simd_into(self.simd));
4938    }
4939}
4940impl<S: Simd> core::ops::Sub<f32x16<S>> for f32 {
4941    type Output = f32x16<S>;
4942    #[inline(always)]
4943    fn sub(self, rhs: f32x16<S>) -> Self::Output {
4944        rhs.simd.sub_f32x16(self.simd_into(rhs.simd), rhs)
4945    }
4946}
4947impl<S: Simd> core::ops::Mul for f32x16<S> {
4948    type Output = Self;
4949    #[doc = "Multiply two vectors element-wise."]
4950    #[inline(always)]
4951    fn mul(self, rhs: Self) -> Self::Output {
4952        self.simd.mul_f32x16(self, rhs)
4953    }
4954}
4955impl<S: Simd> core::ops::MulAssign for f32x16<S> {
4956    #[doc = "Multiply two vectors element-wise."]
4957    #[inline(always)]
4958    fn mul_assign(&mut self, rhs: Self) {
4959        *self = self.simd.mul_f32x16(*self, rhs);
4960    }
4961}
4962impl<S: Simd> core::ops::Mul<f32> for f32x16<S> {
4963    type Output = Self;
4964    #[inline(always)]
4965    fn mul(self, rhs: f32) -> Self::Output {
4966        self.simd.mul_f32x16(self, rhs.simd_into(self.simd))
4967    }
4968}
4969impl<S: Simd> core::ops::MulAssign<f32> for f32x16<S> {
4970    #[inline(always)]
4971    fn mul_assign(&mut self, rhs: f32) {
4972        *self = self.simd.mul_f32x16(*self, rhs.simd_into(self.simd));
4973    }
4974}
4975impl<S: Simd> core::ops::Mul<f32x16<S>> for f32 {
4976    type Output = f32x16<S>;
4977    #[inline(always)]
4978    fn mul(self, rhs: f32x16<S>) -> Self::Output {
4979        rhs.simd.mul_f32x16(self.simd_into(rhs.simd), rhs)
4980    }
4981}
4982impl<S: Simd> core::ops::Div for f32x16<S> {
4983    type Output = Self;
4984    #[doc = "Divide two vectors element-wise."]
4985    #[inline(always)]
4986    fn div(self, rhs: Self) -> Self::Output {
4987        self.simd.div_f32x16(self, rhs)
4988    }
4989}
4990impl<S: Simd> core::ops::DivAssign for f32x16<S> {
4991    #[doc = "Divide two vectors element-wise."]
4992    #[inline(always)]
4993    fn div_assign(&mut self, rhs: Self) {
4994        *self = self.simd.div_f32x16(*self, rhs);
4995    }
4996}
4997impl<S: Simd> core::ops::Div<f32> for f32x16<S> {
4998    type Output = Self;
4999    #[inline(always)]
5000    fn div(self, rhs: f32) -> Self::Output {
5001        self.simd.div_f32x16(self, rhs.simd_into(self.simd))
5002    }
5003}
5004impl<S: Simd> core::ops::DivAssign<f32> for f32x16<S> {
5005    #[inline(always)]
5006    fn div_assign(&mut self, rhs: f32) {
5007        *self = self.simd.div_f32x16(*self, rhs.simd_into(self.simd));
5008    }
5009}
5010impl<S: Simd> core::ops::Div<f32x16<S>> for f32 {
5011    type Output = f32x16<S>;
5012    #[inline(always)]
5013    fn div(self, rhs: f32x16<S>) -> Self::Output {
5014        rhs.simd.div_f32x16(self.simd_into(rhs.simd), rhs)
5015    }
5016}
5017impl<S: Simd> core::ops::Neg for i8x64<S> {
5018    type Output = Self;
5019    #[doc = "Negate each element of the vector, wrapping on overflow."]
5020    #[inline(always)]
5021    fn neg(self) -> Self::Output {
5022        self.simd.neg_i8x64(self)
5023    }
5024}
5025impl<S: Simd> core::ops::Add for i8x64<S> {
5026    type Output = Self;
5027    #[doc = "Add two vectors element-wise, wrapping on overflow."]
5028    #[inline(always)]
5029    fn add(self, rhs: Self) -> Self::Output {
5030        self.simd.add_i8x64(self, rhs)
5031    }
5032}
5033impl<S: Simd> core::ops::AddAssign for i8x64<S> {
5034    #[doc = "Add two vectors element-wise, wrapping on overflow."]
5035    #[inline(always)]
5036    fn add_assign(&mut self, rhs: Self) {
5037        *self = self.simd.add_i8x64(*self, rhs);
5038    }
5039}
5040impl<S: Simd> core::ops::Add<i8> for i8x64<S> {
5041    type Output = Self;
5042    #[inline(always)]
5043    fn add(self, rhs: i8) -> Self::Output {
5044        self.simd.add_i8x64(self, rhs.simd_into(self.simd))
5045    }
5046}
5047impl<S: Simd> core::ops::AddAssign<i8> for i8x64<S> {
5048    #[inline(always)]
5049    fn add_assign(&mut self, rhs: i8) {
5050        *self = self.simd.add_i8x64(*self, rhs.simd_into(self.simd));
5051    }
5052}
5053impl<S: Simd> core::ops::Add<i8x64<S>> for i8 {
5054    type Output = i8x64<S>;
5055    #[inline(always)]
5056    fn add(self, rhs: i8x64<S>) -> Self::Output {
5057        rhs.simd.add_i8x64(self.simd_into(rhs.simd), rhs)
5058    }
5059}
5060impl<S: Simd> core::ops::Sub for i8x64<S> {
5061    type Output = Self;
5062    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
5063    #[inline(always)]
5064    fn sub(self, rhs: Self) -> Self::Output {
5065        self.simd.sub_i8x64(self, rhs)
5066    }
5067}
5068impl<S: Simd> core::ops::SubAssign for i8x64<S> {
5069    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
5070    #[inline(always)]
5071    fn sub_assign(&mut self, rhs: Self) {
5072        *self = self.simd.sub_i8x64(*self, rhs);
5073    }
5074}
5075impl<S: Simd> core::ops::Sub<i8> for i8x64<S> {
5076    type Output = Self;
5077    #[inline(always)]
5078    fn sub(self, rhs: i8) -> Self::Output {
5079        self.simd.sub_i8x64(self, rhs.simd_into(self.simd))
5080    }
5081}
5082impl<S: Simd> core::ops::SubAssign<i8> for i8x64<S> {
5083    #[inline(always)]
5084    fn sub_assign(&mut self, rhs: i8) {
5085        *self = self.simd.sub_i8x64(*self, rhs.simd_into(self.simd));
5086    }
5087}
5088impl<S: Simd> core::ops::Sub<i8x64<S>> for i8 {
5089    type Output = i8x64<S>;
5090    #[inline(always)]
5091    fn sub(self, rhs: i8x64<S>) -> Self::Output {
5092        rhs.simd.sub_i8x64(self.simd_into(rhs.simd), rhs)
5093    }
5094}
5095impl<S: Simd> core::ops::Mul for i8x64<S> {
5096    type Output = Self;
5097    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
5098    #[inline(always)]
5099    fn mul(self, rhs: Self) -> Self::Output {
5100        self.simd.mul_i8x64(self, rhs)
5101    }
5102}
5103impl<S: Simd> core::ops::MulAssign for i8x64<S> {
5104    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
5105    #[inline(always)]
5106    fn mul_assign(&mut self, rhs: Self) {
5107        *self = self.simd.mul_i8x64(*self, rhs);
5108    }
5109}
5110impl<S: Simd> core::ops::Mul<i8> for i8x64<S> {
5111    type Output = Self;
5112    #[inline(always)]
5113    fn mul(self, rhs: i8) -> Self::Output {
5114        self.simd.mul_i8x64(self, rhs.simd_into(self.simd))
5115    }
5116}
5117impl<S: Simd> core::ops::MulAssign<i8> for i8x64<S> {
5118    #[inline(always)]
5119    fn mul_assign(&mut self, rhs: i8) {
5120        *self = self.simd.mul_i8x64(*self, rhs.simd_into(self.simd));
5121    }
5122}
5123impl<S: Simd> core::ops::Mul<i8x64<S>> for i8 {
5124    type Output = i8x64<S>;
5125    #[inline(always)]
5126    fn mul(self, rhs: i8x64<S>) -> Self::Output {
5127        rhs.simd.mul_i8x64(self.simd_into(rhs.simd), rhs)
5128    }
5129}
5130impl<S: Simd> core::ops::BitAnd for i8x64<S> {
5131    type Output = Self;
5132    #[doc = "Compute the bitwise AND of two vectors."]
5133    #[inline(always)]
5134    fn bitand(self, rhs: Self) -> Self::Output {
5135        self.simd.and_i8x64(self, rhs)
5136    }
5137}
5138impl<S: Simd> core::ops::BitAndAssign for i8x64<S> {
5139    #[doc = "Compute the bitwise AND of two vectors."]
5140    #[inline(always)]
5141    fn bitand_assign(&mut self, rhs: Self) {
5142        *self = self.simd.and_i8x64(*self, rhs);
5143    }
5144}
5145impl<S: Simd> core::ops::BitAnd<i8> for i8x64<S> {
5146    type Output = Self;
5147    #[inline(always)]
5148    fn bitand(self, rhs: i8) -> Self::Output {
5149        self.simd.and_i8x64(self, rhs.simd_into(self.simd))
5150    }
5151}
5152impl<S: Simd> core::ops::BitAndAssign<i8> for i8x64<S> {
5153    #[inline(always)]
5154    fn bitand_assign(&mut self, rhs: i8) {
5155        *self = self.simd.and_i8x64(*self, rhs.simd_into(self.simd));
5156    }
5157}
5158impl<S: Simd> core::ops::BitAnd<i8x64<S>> for i8 {
5159    type Output = i8x64<S>;
5160    #[inline(always)]
5161    fn bitand(self, rhs: i8x64<S>) -> Self::Output {
5162        rhs.simd.and_i8x64(self.simd_into(rhs.simd), rhs)
5163    }
5164}
5165impl<S: Simd> core::ops::BitOr for i8x64<S> {
5166    type Output = Self;
5167    #[doc = "Compute the bitwise OR of two vectors."]
5168    #[inline(always)]
5169    fn bitor(self, rhs: Self) -> Self::Output {
5170        self.simd.or_i8x64(self, rhs)
5171    }
5172}
5173impl<S: Simd> core::ops::BitOrAssign for i8x64<S> {
5174    #[doc = "Compute the bitwise OR of two vectors."]
5175    #[inline(always)]
5176    fn bitor_assign(&mut self, rhs: Self) {
5177        *self = self.simd.or_i8x64(*self, rhs);
5178    }
5179}
5180impl<S: Simd> core::ops::BitOr<i8> for i8x64<S> {
5181    type Output = Self;
5182    #[inline(always)]
5183    fn bitor(self, rhs: i8) -> Self::Output {
5184        self.simd.or_i8x64(self, rhs.simd_into(self.simd))
5185    }
5186}
5187impl<S: Simd> core::ops::BitOrAssign<i8> for i8x64<S> {
5188    #[inline(always)]
5189    fn bitor_assign(&mut self, rhs: i8) {
5190        *self = self.simd.or_i8x64(*self, rhs.simd_into(self.simd));
5191    }
5192}
5193impl<S: Simd> core::ops::BitOr<i8x64<S>> for i8 {
5194    type Output = i8x64<S>;
5195    #[inline(always)]
5196    fn bitor(self, rhs: i8x64<S>) -> Self::Output {
5197        rhs.simd.or_i8x64(self.simd_into(rhs.simd), rhs)
5198    }
5199}
5200impl<S: Simd> core::ops::BitXor for i8x64<S> {
5201    type Output = Self;
5202    #[doc = "Compute the bitwise XOR of two vectors."]
5203    #[inline(always)]
5204    fn bitxor(self, rhs: Self) -> Self::Output {
5205        self.simd.xor_i8x64(self, rhs)
5206    }
5207}
5208impl<S: Simd> core::ops::BitXorAssign for i8x64<S> {
5209    #[doc = "Compute the bitwise XOR of two vectors."]
5210    #[inline(always)]
5211    fn bitxor_assign(&mut self, rhs: Self) {
5212        *self = self.simd.xor_i8x64(*self, rhs);
5213    }
5214}
5215impl<S: Simd> core::ops::BitXor<i8> for i8x64<S> {
5216    type Output = Self;
5217    #[inline(always)]
5218    fn bitxor(self, rhs: i8) -> Self::Output {
5219        self.simd.xor_i8x64(self, rhs.simd_into(self.simd))
5220    }
5221}
5222impl<S: Simd> core::ops::BitXorAssign<i8> for i8x64<S> {
5223    #[inline(always)]
5224    fn bitxor_assign(&mut self, rhs: i8) {
5225        *self = self.simd.xor_i8x64(*self, rhs.simd_into(self.simd));
5226    }
5227}
5228impl<S: Simd> core::ops::BitXor<i8x64<S>> for i8 {
5229    type Output = i8x64<S>;
5230    #[inline(always)]
5231    fn bitxor(self, rhs: i8x64<S>) -> Self::Output {
5232        rhs.simd.xor_i8x64(self.simd_into(rhs.simd), rhs)
5233    }
5234}
5235impl<S: Simd> core::ops::Not for i8x64<S> {
5236    type Output = Self;
5237    #[doc = "Compute the bitwise NOT of the vector."]
5238    #[inline(always)]
5239    fn not(self) -> Self::Output {
5240        self.simd.not_i8x64(self)
5241    }
5242}
5243impl<S: Simd> core::ops::Shl<u32> for i8x64<S> {
5244    type Output = Self;
5245    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
5246    #[inline(always)]
5247    fn shl(self, rhs: u32) -> Self::Output {
5248        self.simd.shl_i8x64(self, rhs)
5249    }
5250}
5251impl<S: Simd> core::ops::ShlAssign<u32> for i8x64<S> {
5252    #[inline(always)]
5253    fn shl_assign(&mut self, rhs: u32) {
5254        *self = self.simd.shl_i8x64(*self, rhs);
5255    }
5256}
5257impl<S: Simd> core::ops::Shl for i8x64<S> {
5258    type Output = Self;
5259    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5260    #[inline(always)]
5261    fn shl(self, rhs: Self) -> Self::Output {
5262        self.simd.shlv_i8x64(self, rhs)
5263    }
5264}
5265impl<S: Simd> core::ops::ShlAssign for i8x64<S> {
5266    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5267    #[inline(always)]
5268    fn shl_assign(&mut self, rhs: Self) {
5269        *self = self.simd.shlv_i8x64(*self, rhs);
5270    }
5271}
5272impl<S: Simd> core::ops::Shr<u32> for i8x64<S> {
5273    type Output = Self;
5274    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
5275    #[inline(always)]
5276    fn shr(self, rhs: u32) -> Self::Output {
5277        self.simd.shr_i8x64(self, rhs)
5278    }
5279}
5280impl<S: Simd> core::ops::ShrAssign<u32> for i8x64<S> {
5281    #[inline(always)]
5282    fn shr_assign(&mut self, rhs: u32) {
5283        *self = self.simd.shr_i8x64(*self, rhs);
5284    }
5285}
5286impl<S: Simd> core::ops::Shr for i8x64<S> {
5287    type Output = Self;
5288    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5289    #[inline(always)]
5290    fn shr(self, rhs: Self) -> Self::Output {
5291        self.simd.shrv_i8x64(self, rhs)
5292    }
5293}
5294impl<S: Simd> core::ops::ShrAssign for i8x64<S> {
5295    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5296    #[inline(always)]
5297    fn shr_assign(&mut self, rhs: Self) {
5298        *self = self.simd.shrv_i8x64(*self, rhs);
5299    }
5300}
5301impl<S: Simd> core::ops::Add for u8x64<S> {
5302    type Output = Self;
5303    #[doc = "Add two vectors element-wise, wrapping on overflow."]
5304    #[inline(always)]
5305    fn add(self, rhs: Self) -> Self::Output {
5306        self.simd.add_u8x64(self, rhs)
5307    }
5308}
5309impl<S: Simd> core::ops::AddAssign for u8x64<S> {
5310    #[doc = "Add two vectors element-wise, wrapping on overflow."]
5311    #[inline(always)]
5312    fn add_assign(&mut self, rhs: Self) {
5313        *self = self.simd.add_u8x64(*self, rhs);
5314    }
5315}
5316impl<S: Simd> core::ops::Add<u8> for u8x64<S> {
5317    type Output = Self;
5318    #[inline(always)]
5319    fn add(self, rhs: u8) -> Self::Output {
5320        self.simd.add_u8x64(self, rhs.simd_into(self.simd))
5321    }
5322}
5323impl<S: Simd> core::ops::AddAssign<u8> for u8x64<S> {
5324    #[inline(always)]
5325    fn add_assign(&mut self, rhs: u8) {
5326        *self = self.simd.add_u8x64(*self, rhs.simd_into(self.simd));
5327    }
5328}
5329impl<S: Simd> core::ops::Add<u8x64<S>> for u8 {
5330    type Output = u8x64<S>;
5331    #[inline(always)]
5332    fn add(self, rhs: u8x64<S>) -> Self::Output {
5333        rhs.simd.add_u8x64(self.simd_into(rhs.simd), rhs)
5334    }
5335}
5336impl<S: Simd> core::ops::Sub for u8x64<S> {
5337    type Output = Self;
5338    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
5339    #[inline(always)]
5340    fn sub(self, rhs: Self) -> Self::Output {
5341        self.simd.sub_u8x64(self, rhs)
5342    }
5343}
5344impl<S: Simd> core::ops::SubAssign for u8x64<S> {
5345    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
5346    #[inline(always)]
5347    fn sub_assign(&mut self, rhs: Self) {
5348        *self = self.simd.sub_u8x64(*self, rhs);
5349    }
5350}
5351impl<S: Simd> core::ops::Sub<u8> for u8x64<S> {
5352    type Output = Self;
5353    #[inline(always)]
5354    fn sub(self, rhs: u8) -> Self::Output {
5355        self.simd.sub_u8x64(self, rhs.simd_into(self.simd))
5356    }
5357}
5358impl<S: Simd> core::ops::SubAssign<u8> for u8x64<S> {
5359    #[inline(always)]
5360    fn sub_assign(&mut self, rhs: u8) {
5361        *self = self.simd.sub_u8x64(*self, rhs.simd_into(self.simd));
5362    }
5363}
5364impl<S: Simd> core::ops::Sub<u8x64<S>> for u8 {
5365    type Output = u8x64<S>;
5366    #[inline(always)]
5367    fn sub(self, rhs: u8x64<S>) -> Self::Output {
5368        rhs.simd.sub_u8x64(self.simd_into(rhs.simd), rhs)
5369    }
5370}
5371impl<S: Simd> core::ops::Mul for u8x64<S> {
5372    type Output = Self;
5373    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
5374    #[inline(always)]
5375    fn mul(self, rhs: Self) -> Self::Output {
5376        self.simd.mul_u8x64(self, rhs)
5377    }
5378}
5379impl<S: Simd> core::ops::MulAssign for u8x64<S> {
5380    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
5381    #[inline(always)]
5382    fn mul_assign(&mut self, rhs: Self) {
5383        *self = self.simd.mul_u8x64(*self, rhs);
5384    }
5385}
5386impl<S: Simd> core::ops::Mul<u8> for u8x64<S> {
5387    type Output = Self;
5388    #[inline(always)]
5389    fn mul(self, rhs: u8) -> Self::Output {
5390        self.simd.mul_u8x64(self, rhs.simd_into(self.simd))
5391    }
5392}
5393impl<S: Simd> core::ops::MulAssign<u8> for u8x64<S> {
5394    #[inline(always)]
5395    fn mul_assign(&mut self, rhs: u8) {
5396        *self = self.simd.mul_u8x64(*self, rhs.simd_into(self.simd));
5397    }
5398}
5399impl<S: Simd> core::ops::Mul<u8x64<S>> for u8 {
5400    type Output = u8x64<S>;
5401    #[inline(always)]
5402    fn mul(self, rhs: u8x64<S>) -> Self::Output {
5403        rhs.simd.mul_u8x64(self.simd_into(rhs.simd), rhs)
5404    }
5405}
5406impl<S: Simd> core::ops::BitAnd for u8x64<S> {
5407    type Output = Self;
5408    #[doc = "Compute the bitwise AND of two vectors."]
5409    #[inline(always)]
5410    fn bitand(self, rhs: Self) -> Self::Output {
5411        self.simd.and_u8x64(self, rhs)
5412    }
5413}
5414impl<S: Simd> core::ops::BitAndAssign for u8x64<S> {
5415    #[doc = "Compute the bitwise AND of two vectors."]
5416    #[inline(always)]
5417    fn bitand_assign(&mut self, rhs: Self) {
5418        *self = self.simd.and_u8x64(*self, rhs);
5419    }
5420}
5421impl<S: Simd> core::ops::BitAnd<u8> for u8x64<S> {
5422    type Output = Self;
5423    #[inline(always)]
5424    fn bitand(self, rhs: u8) -> Self::Output {
5425        self.simd.and_u8x64(self, rhs.simd_into(self.simd))
5426    }
5427}
5428impl<S: Simd> core::ops::BitAndAssign<u8> for u8x64<S> {
5429    #[inline(always)]
5430    fn bitand_assign(&mut self, rhs: u8) {
5431        *self = self.simd.and_u8x64(*self, rhs.simd_into(self.simd));
5432    }
5433}
5434impl<S: Simd> core::ops::BitAnd<u8x64<S>> for u8 {
5435    type Output = u8x64<S>;
5436    #[inline(always)]
5437    fn bitand(self, rhs: u8x64<S>) -> Self::Output {
5438        rhs.simd.and_u8x64(self.simd_into(rhs.simd), rhs)
5439    }
5440}
5441impl<S: Simd> core::ops::BitOr for u8x64<S> {
5442    type Output = Self;
5443    #[doc = "Compute the bitwise OR of two vectors."]
5444    #[inline(always)]
5445    fn bitor(self, rhs: Self) -> Self::Output {
5446        self.simd.or_u8x64(self, rhs)
5447    }
5448}
5449impl<S: Simd> core::ops::BitOrAssign for u8x64<S> {
5450    #[doc = "Compute the bitwise OR of two vectors."]
5451    #[inline(always)]
5452    fn bitor_assign(&mut self, rhs: Self) {
5453        *self = self.simd.or_u8x64(*self, rhs);
5454    }
5455}
5456impl<S: Simd> core::ops::BitOr<u8> for u8x64<S> {
5457    type Output = Self;
5458    #[inline(always)]
5459    fn bitor(self, rhs: u8) -> Self::Output {
5460        self.simd.or_u8x64(self, rhs.simd_into(self.simd))
5461    }
5462}
5463impl<S: Simd> core::ops::BitOrAssign<u8> for u8x64<S> {
5464    #[inline(always)]
5465    fn bitor_assign(&mut self, rhs: u8) {
5466        *self = self.simd.or_u8x64(*self, rhs.simd_into(self.simd));
5467    }
5468}
5469impl<S: Simd> core::ops::BitOr<u8x64<S>> for u8 {
5470    type Output = u8x64<S>;
5471    #[inline(always)]
5472    fn bitor(self, rhs: u8x64<S>) -> Self::Output {
5473        rhs.simd.or_u8x64(self.simd_into(rhs.simd), rhs)
5474    }
5475}
5476impl<S: Simd> core::ops::BitXor for u8x64<S> {
5477    type Output = Self;
5478    #[doc = "Compute the bitwise XOR of two vectors."]
5479    #[inline(always)]
5480    fn bitxor(self, rhs: Self) -> Self::Output {
5481        self.simd.xor_u8x64(self, rhs)
5482    }
5483}
5484impl<S: Simd> core::ops::BitXorAssign for u8x64<S> {
5485    #[doc = "Compute the bitwise XOR of two vectors."]
5486    #[inline(always)]
5487    fn bitxor_assign(&mut self, rhs: Self) {
5488        *self = self.simd.xor_u8x64(*self, rhs);
5489    }
5490}
5491impl<S: Simd> core::ops::BitXor<u8> for u8x64<S> {
5492    type Output = Self;
5493    #[inline(always)]
5494    fn bitxor(self, rhs: u8) -> Self::Output {
5495        self.simd.xor_u8x64(self, rhs.simd_into(self.simd))
5496    }
5497}
5498impl<S: Simd> core::ops::BitXorAssign<u8> for u8x64<S> {
5499    #[inline(always)]
5500    fn bitxor_assign(&mut self, rhs: u8) {
5501        *self = self.simd.xor_u8x64(*self, rhs.simd_into(self.simd));
5502    }
5503}
5504impl<S: Simd> core::ops::BitXor<u8x64<S>> for u8 {
5505    type Output = u8x64<S>;
5506    #[inline(always)]
5507    fn bitxor(self, rhs: u8x64<S>) -> Self::Output {
5508        rhs.simd.xor_u8x64(self.simd_into(rhs.simd), rhs)
5509    }
5510}
5511impl<S: Simd> core::ops::Not for u8x64<S> {
5512    type Output = Self;
5513    #[doc = "Compute the bitwise NOT of the vector."]
5514    #[inline(always)]
5515    fn not(self) -> Self::Output {
5516        self.simd.not_u8x64(self)
5517    }
5518}
5519impl<S: Simd> core::ops::Shl<u32> for u8x64<S> {
5520    type Output = Self;
5521    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
5522    #[inline(always)]
5523    fn shl(self, rhs: u32) -> Self::Output {
5524        self.simd.shl_u8x64(self, rhs)
5525    }
5526}
5527impl<S: Simd> core::ops::ShlAssign<u32> for u8x64<S> {
5528    #[inline(always)]
5529    fn shl_assign(&mut self, rhs: u32) {
5530        *self = self.simd.shl_u8x64(*self, rhs);
5531    }
5532}
5533impl<S: Simd> core::ops::Shl for u8x64<S> {
5534    type Output = Self;
5535    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5536    #[inline(always)]
5537    fn shl(self, rhs: Self) -> Self::Output {
5538        self.simd.shlv_u8x64(self, rhs)
5539    }
5540}
5541impl<S: Simd> core::ops::ShlAssign for u8x64<S> {
5542    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5543    #[inline(always)]
5544    fn shl_assign(&mut self, rhs: Self) {
5545        *self = self.simd.shlv_u8x64(*self, rhs);
5546    }
5547}
5548impl<S: Simd> core::ops::Shr<u32> for u8x64<S> {
5549    type Output = Self;
5550    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
5551    #[inline(always)]
5552    fn shr(self, rhs: u32) -> Self::Output {
5553        self.simd.shr_u8x64(self, rhs)
5554    }
5555}
5556impl<S: Simd> core::ops::ShrAssign<u32> for u8x64<S> {
5557    #[inline(always)]
5558    fn shr_assign(&mut self, rhs: u32) {
5559        *self = self.simd.shr_u8x64(*self, rhs);
5560    }
5561}
5562impl<S: Simd> core::ops::Shr for u8x64<S> {
5563    type Output = Self;
5564    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5565    #[inline(always)]
5566    fn shr(self, rhs: Self) -> Self::Output {
5567        self.simd.shrv_u8x64(self, rhs)
5568    }
5569}
5570impl<S: Simd> core::ops::ShrAssign for u8x64<S> {
5571    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5572    #[inline(always)]
5573    fn shr_assign(&mut self, rhs: Self) {
5574        *self = self.simd.shrv_u8x64(*self, rhs);
5575    }
5576}
5577impl<S: Simd> core::ops::BitAnd for mask8x64<S> {
5578    type Output = Self;
5579    #[doc = "Compute the logical AND of two masks."]
5580    #[inline(always)]
5581    fn bitand(self, rhs: Self) -> Self::Output {
5582        self.simd.and_mask8x64(self, rhs)
5583    }
5584}
5585impl<S: Simd> core::ops::BitAndAssign for mask8x64<S> {
5586    #[doc = "Compute the logical AND of two masks."]
5587    #[inline(always)]
5588    fn bitand_assign(&mut self, rhs: Self) {
5589        *self = self.simd.and_mask8x64(*self, rhs);
5590    }
5591}
5592impl<S: Simd> core::ops::BitAnd<i8> for mask8x64<S> {
5593    type Output = Self;
5594    #[inline(always)]
5595    fn bitand(self, rhs: i8) -> Self::Output {
5596        self.simd.and_mask8x64(self, rhs.simd_into(self.simd))
5597    }
5598}
5599impl<S: Simd> core::ops::BitAndAssign<i8> for mask8x64<S> {
5600    #[inline(always)]
5601    fn bitand_assign(&mut self, rhs: i8) {
5602        *self = self.simd.and_mask8x64(*self, rhs.simd_into(self.simd));
5603    }
5604}
5605impl<S: Simd> core::ops::BitAnd<mask8x64<S>> for i8 {
5606    type Output = mask8x64<S>;
5607    #[inline(always)]
5608    fn bitand(self, rhs: mask8x64<S>) -> Self::Output {
5609        rhs.simd.and_mask8x64(self.simd_into(rhs.simd), rhs)
5610    }
5611}
5612impl<S: Simd> core::ops::BitOr for mask8x64<S> {
5613    type Output = Self;
5614    #[doc = "Compute the logical OR of two masks."]
5615    #[inline(always)]
5616    fn bitor(self, rhs: Self) -> Self::Output {
5617        self.simd.or_mask8x64(self, rhs)
5618    }
5619}
5620impl<S: Simd> core::ops::BitOrAssign for mask8x64<S> {
5621    #[doc = "Compute the logical OR of two masks."]
5622    #[inline(always)]
5623    fn bitor_assign(&mut self, rhs: Self) {
5624        *self = self.simd.or_mask8x64(*self, rhs);
5625    }
5626}
5627impl<S: Simd> core::ops::BitOr<i8> for mask8x64<S> {
5628    type Output = Self;
5629    #[inline(always)]
5630    fn bitor(self, rhs: i8) -> Self::Output {
5631        self.simd.or_mask8x64(self, rhs.simd_into(self.simd))
5632    }
5633}
5634impl<S: Simd> core::ops::BitOrAssign<i8> for mask8x64<S> {
5635    #[inline(always)]
5636    fn bitor_assign(&mut self, rhs: i8) {
5637        *self = self.simd.or_mask8x64(*self, rhs.simd_into(self.simd));
5638    }
5639}
5640impl<S: Simd> core::ops::BitOr<mask8x64<S>> for i8 {
5641    type Output = mask8x64<S>;
5642    #[inline(always)]
5643    fn bitor(self, rhs: mask8x64<S>) -> Self::Output {
5644        rhs.simd.or_mask8x64(self.simd_into(rhs.simd), rhs)
5645    }
5646}
5647impl<S: Simd> core::ops::BitXor for mask8x64<S> {
5648    type Output = Self;
5649    #[doc = "Compute the logical XOR of two masks."]
5650    #[inline(always)]
5651    fn bitxor(self, rhs: Self) -> Self::Output {
5652        self.simd.xor_mask8x64(self, rhs)
5653    }
5654}
5655impl<S: Simd> core::ops::BitXorAssign for mask8x64<S> {
5656    #[doc = "Compute the logical XOR of two masks."]
5657    #[inline(always)]
5658    fn bitxor_assign(&mut self, rhs: Self) {
5659        *self = self.simd.xor_mask8x64(*self, rhs);
5660    }
5661}
5662impl<S: Simd> core::ops::BitXor<i8> for mask8x64<S> {
5663    type Output = Self;
5664    #[inline(always)]
5665    fn bitxor(self, rhs: i8) -> Self::Output {
5666        self.simd.xor_mask8x64(self, rhs.simd_into(self.simd))
5667    }
5668}
5669impl<S: Simd> core::ops::BitXorAssign<i8> for mask8x64<S> {
5670    #[inline(always)]
5671    fn bitxor_assign(&mut self, rhs: i8) {
5672        *self = self.simd.xor_mask8x64(*self, rhs.simd_into(self.simd));
5673    }
5674}
5675impl<S: Simd> core::ops::BitXor<mask8x64<S>> for i8 {
5676    type Output = mask8x64<S>;
5677    #[inline(always)]
5678    fn bitxor(self, rhs: mask8x64<S>) -> Self::Output {
5679        rhs.simd.xor_mask8x64(self.simd_into(rhs.simd), rhs)
5680    }
5681}
5682impl<S: Simd> core::ops::Not for mask8x64<S> {
5683    type Output = Self;
5684    #[doc = "Compute the logical NOT of the mask."]
5685    #[inline(always)]
5686    fn not(self) -> Self::Output {
5687        self.simd.not_mask8x64(self)
5688    }
5689}
5690impl<S: Simd> core::ops::Neg for i16x32<S> {
5691    type Output = Self;
5692    #[doc = "Negate each element of the vector, wrapping on overflow."]
5693    #[inline(always)]
5694    fn neg(self) -> Self::Output {
5695        self.simd.neg_i16x32(self)
5696    }
5697}
5698impl<S: Simd> core::ops::Add for i16x32<S> {
5699    type Output = Self;
5700    #[doc = "Add two vectors element-wise, wrapping on overflow."]
5701    #[inline(always)]
5702    fn add(self, rhs: Self) -> Self::Output {
5703        self.simd.add_i16x32(self, rhs)
5704    }
5705}
5706impl<S: Simd> core::ops::AddAssign for i16x32<S> {
5707    #[doc = "Add two vectors element-wise, wrapping on overflow."]
5708    #[inline(always)]
5709    fn add_assign(&mut self, rhs: Self) {
5710        *self = self.simd.add_i16x32(*self, rhs);
5711    }
5712}
5713impl<S: Simd> core::ops::Add<i16> for i16x32<S> {
5714    type Output = Self;
5715    #[inline(always)]
5716    fn add(self, rhs: i16) -> Self::Output {
5717        self.simd.add_i16x32(self, rhs.simd_into(self.simd))
5718    }
5719}
5720impl<S: Simd> core::ops::AddAssign<i16> for i16x32<S> {
5721    #[inline(always)]
5722    fn add_assign(&mut self, rhs: i16) {
5723        *self = self.simd.add_i16x32(*self, rhs.simd_into(self.simd));
5724    }
5725}
5726impl<S: Simd> core::ops::Add<i16x32<S>> for i16 {
5727    type Output = i16x32<S>;
5728    #[inline(always)]
5729    fn add(self, rhs: i16x32<S>) -> Self::Output {
5730        rhs.simd.add_i16x32(self.simd_into(rhs.simd), rhs)
5731    }
5732}
5733impl<S: Simd> core::ops::Sub for i16x32<S> {
5734    type Output = Self;
5735    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
5736    #[inline(always)]
5737    fn sub(self, rhs: Self) -> Self::Output {
5738        self.simd.sub_i16x32(self, rhs)
5739    }
5740}
5741impl<S: Simd> core::ops::SubAssign for i16x32<S> {
5742    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
5743    #[inline(always)]
5744    fn sub_assign(&mut self, rhs: Self) {
5745        *self = self.simd.sub_i16x32(*self, rhs);
5746    }
5747}
5748impl<S: Simd> core::ops::Sub<i16> for i16x32<S> {
5749    type Output = Self;
5750    #[inline(always)]
5751    fn sub(self, rhs: i16) -> Self::Output {
5752        self.simd.sub_i16x32(self, rhs.simd_into(self.simd))
5753    }
5754}
5755impl<S: Simd> core::ops::SubAssign<i16> for i16x32<S> {
5756    #[inline(always)]
5757    fn sub_assign(&mut self, rhs: i16) {
5758        *self = self.simd.sub_i16x32(*self, rhs.simd_into(self.simd));
5759    }
5760}
5761impl<S: Simd> core::ops::Sub<i16x32<S>> for i16 {
5762    type Output = i16x32<S>;
5763    #[inline(always)]
5764    fn sub(self, rhs: i16x32<S>) -> Self::Output {
5765        rhs.simd.sub_i16x32(self.simd_into(rhs.simd), rhs)
5766    }
5767}
5768impl<S: Simd> core::ops::Mul for i16x32<S> {
5769    type Output = Self;
5770    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
5771    #[inline(always)]
5772    fn mul(self, rhs: Self) -> Self::Output {
5773        self.simd.mul_i16x32(self, rhs)
5774    }
5775}
5776impl<S: Simd> core::ops::MulAssign for i16x32<S> {
5777    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
5778    #[inline(always)]
5779    fn mul_assign(&mut self, rhs: Self) {
5780        *self = self.simd.mul_i16x32(*self, rhs);
5781    }
5782}
5783impl<S: Simd> core::ops::Mul<i16> for i16x32<S> {
5784    type Output = Self;
5785    #[inline(always)]
5786    fn mul(self, rhs: i16) -> Self::Output {
5787        self.simd.mul_i16x32(self, rhs.simd_into(self.simd))
5788    }
5789}
5790impl<S: Simd> core::ops::MulAssign<i16> for i16x32<S> {
5791    #[inline(always)]
5792    fn mul_assign(&mut self, rhs: i16) {
5793        *self = self.simd.mul_i16x32(*self, rhs.simd_into(self.simd));
5794    }
5795}
5796impl<S: Simd> core::ops::Mul<i16x32<S>> for i16 {
5797    type Output = i16x32<S>;
5798    #[inline(always)]
5799    fn mul(self, rhs: i16x32<S>) -> Self::Output {
5800        rhs.simd.mul_i16x32(self.simd_into(rhs.simd), rhs)
5801    }
5802}
5803impl<S: Simd> core::ops::BitAnd for i16x32<S> {
5804    type Output = Self;
5805    #[doc = "Compute the bitwise AND of two vectors."]
5806    #[inline(always)]
5807    fn bitand(self, rhs: Self) -> Self::Output {
5808        self.simd.and_i16x32(self, rhs)
5809    }
5810}
5811impl<S: Simd> core::ops::BitAndAssign for i16x32<S> {
5812    #[doc = "Compute the bitwise AND of two vectors."]
5813    #[inline(always)]
5814    fn bitand_assign(&mut self, rhs: Self) {
5815        *self = self.simd.and_i16x32(*self, rhs);
5816    }
5817}
5818impl<S: Simd> core::ops::BitAnd<i16> for i16x32<S> {
5819    type Output = Self;
5820    #[inline(always)]
5821    fn bitand(self, rhs: i16) -> Self::Output {
5822        self.simd.and_i16x32(self, rhs.simd_into(self.simd))
5823    }
5824}
5825impl<S: Simd> core::ops::BitAndAssign<i16> for i16x32<S> {
5826    #[inline(always)]
5827    fn bitand_assign(&mut self, rhs: i16) {
5828        *self = self.simd.and_i16x32(*self, rhs.simd_into(self.simd));
5829    }
5830}
5831impl<S: Simd> core::ops::BitAnd<i16x32<S>> for i16 {
5832    type Output = i16x32<S>;
5833    #[inline(always)]
5834    fn bitand(self, rhs: i16x32<S>) -> Self::Output {
5835        rhs.simd.and_i16x32(self.simd_into(rhs.simd), rhs)
5836    }
5837}
5838impl<S: Simd> core::ops::BitOr for i16x32<S> {
5839    type Output = Self;
5840    #[doc = "Compute the bitwise OR of two vectors."]
5841    #[inline(always)]
5842    fn bitor(self, rhs: Self) -> Self::Output {
5843        self.simd.or_i16x32(self, rhs)
5844    }
5845}
5846impl<S: Simd> core::ops::BitOrAssign for i16x32<S> {
5847    #[doc = "Compute the bitwise OR of two vectors."]
5848    #[inline(always)]
5849    fn bitor_assign(&mut self, rhs: Self) {
5850        *self = self.simd.or_i16x32(*self, rhs);
5851    }
5852}
5853impl<S: Simd> core::ops::BitOr<i16> for i16x32<S> {
5854    type Output = Self;
5855    #[inline(always)]
5856    fn bitor(self, rhs: i16) -> Self::Output {
5857        self.simd.or_i16x32(self, rhs.simd_into(self.simd))
5858    }
5859}
5860impl<S: Simd> core::ops::BitOrAssign<i16> for i16x32<S> {
5861    #[inline(always)]
5862    fn bitor_assign(&mut self, rhs: i16) {
5863        *self = self.simd.or_i16x32(*self, rhs.simd_into(self.simd));
5864    }
5865}
5866impl<S: Simd> core::ops::BitOr<i16x32<S>> for i16 {
5867    type Output = i16x32<S>;
5868    #[inline(always)]
5869    fn bitor(self, rhs: i16x32<S>) -> Self::Output {
5870        rhs.simd.or_i16x32(self.simd_into(rhs.simd), rhs)
5871    }
5872}
5873impl<S: Simd> core::ops::BitXor for i16x32<S> {
5874    type Output = Self;
5875    #[doc = "Compute the bitwise XOR of two vectors."]
5876    #[inline(always)]
5877    fn bitxor(self, rhs: Self) -> Self::Output {
5878        self.simd.xor_i16x32(self, rhs)
5879    }
5880}
5881impl<S: Simd> core::ops::BitXorAssign for i16x32<S> {
5882    #[doc = "Compute the bitwise XOR of two vectors."]
5883    #[inline(always)]
5884    fn bitxor_assign(&mut self, rhs: Self) {
5885        *self = self.simd.xor_i16x32(*self, rhs);
5886    }
5887}
5888impl<S: Simd> core::ops::BitXor<i16> for i16x32<S> {
5889    type Output = Self;
5890    #[inline(always)]
5891    fn bitxor(self, rhs: i16) -> Self::Output {
5892        self.simd.xor_i16x32(self, rhs.simd_into(self.simd))
5893    }
5894}
5895impl<S: Simd> core::ops::BitXorAssign<i16> for i16x32<S> {
5896    #[inline(always)]
5897    fn bitxor_assign(&mut self, rhs: i16) {
5898        *self = self.simd.xor_i16x32(*self, rhs.simd_into(self.simd));
5899    }
5900}
5901impl<S: Simd> core::ops::BitXor<i16x32<S>> for i16 {
5902    type Output = i16x32<S>;
5903    #[inline(always)]
5904    fn bitxor(self, rhs: i16x32<S>) -> Self::Output {
5905        rhs.simd.xor_i16x32(self.simd_into(rhs.simd), rhs)
5906    }
5907}
5908impl<S: Simd> core::ops::Not for i16x32<S> {
5909    type Output = Self;
5910    #[doc = "Compute the bitwise NOT of the vector."]
5911    #[inline(always)]
5912    fn not(self) -> Self::Output {
5913        self.simd.not_i16x32(self)
5914    }
5915}
5916impl<S: Simd> core::ops::Shl<u32> for i16x32<S> {
5917    type Output = Self;
5918    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
5919    #[inline(always)]
5920    fn shl(self, rhs: u32) -> Self::Output {
5921        self.simd.shl_i16x32(self, rhs)
5922    }
5923}
5924impl<S: Simd> core::ops::ShlAssign<u32> for i16x32<S> {
5925    #[inline(always)]
5926    fn shl_assign(&mut self, rhs: u32) {
5927        *self = self.simd.shl_i16x32(*self, rhs);
5928    }
5929}
5930impl<S: Simd> core::ops::Shl for i16x32<S> {
5931    type Output = Self;
5932    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5933    #[inline(always)]
5934    fn shl(self, rhs: Self) -> Self::Output {
5935        self.simd.shlv_i16x32(self, rhs)
5936    }
5937}
5938impl<S: Simd> core::ops::ShlAssign for i16x32<S> {
5939    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5940    #[inline(always)]
5941    fn shl_assign(&mut self, rhs: Self) {
5942        *self = self.simd.shlv_i16x32(*self, rhs);
5943    }
5944}
5945impl<S: Simd> core::ops::Shr<u32> for i16x32<S> {
5946    type Output = Self;
5947    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
5948    #[inline(always)]
5949    fn shr(self, rhs: u32) -> Self::Output {
5950        self.simd.shr_i16x32(self, rhs)
5951    }
5952}
5953impl<S: Simd> core::ops::ShrAssign<u32> for i16x32<S> {
5954    #[inline(always)]
5955    fn shr_assign(&mut self, rhs: u32) {
5956        *self = self.simd.shr_i16x32(*self, rhs);
5957    }
5958}
5959impl<S: Simd> core::ops::Shr for i16x32<S> {
5960    type Output = Self;
5961    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5962    #[inline(always)]
5963    fn shr(self, rhs: Self) -> Self::Output {
5964        self.simd.shrv_i16x32(self, rhs)
5965    }
5966}
5967impl<S: Simd> core::ops::ShrAssign for i16x32<S> {
5968    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
5969    #[inline(always)]
5970    fn shr_assign(&mut self, rhs: Self) {
5971        *self = self.simd.shrv_i16x32(*self, rhs);
5972    }
5973}
5974impl<S: Simd> core::ops::Add for u16x32<S> {
5975    type Output = Self;
5976    #[doc = "Add two vectors element-wise, wrapping on overflow."]
5977    #[inline(always)]
5978    fn add(self, rhs: Self) -> Self::Output {
5979        self.simd.add_u16x32(self, rhs)
5980    }
5981}
5982impl<S: Simd> core::ops::AddAssign for u16x32<S> {
5983    #[doc = "Add two vectors element-wise, wrapping on overflow."]
5984    #[inline(always)]
5985    fn add_assign(&mut self, rhs: Self) {
5986        *self = self.simd.add_u16x32(*self, rhs);
5987    }
5988}
5989impl<S: Simd> core::ops::Add<u16> for u16x32<S> {
5990    type Output = Self;
5991    #[inline(always)]
5992    fn add(self, rhs: u16) -> Self::Output {
5993        self.simd.add_u16x32(self, rhs.simd_into(self.simd))
5994    }
5995}
5996impl<S: Simd> core::ops::AddAssign<u16> for u16x32<S> {
5997    #[inline(always)]
5998    fn add_assign(&mut self, rhs: u16) {
5999        *self = self.simd.add_u16x32(*self, rhs.simd_into(self.simd));
6000    }
6001}
6002impl<S: Simd> core::ops::Add<u16x32<S>> for u16 {
6003    type Output = u16x32<S>;
6004    #[inline(always)]
6005    fn add(self, rhs: u16x32<S>) -> Self::Output {
6006        rhs.simd.add_u16x32(self.simd_into(rhs.simd), rhs)
6007    }
6008}
6009impl<S: Simd> core::ops::Sub for u16x32<S> {
6010    type Output = Self;
6011    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
6012    #[inline(always)]
6013    fn sub(self, rhs: Self) -> Self::Output {
6014        self.simd.sub_u16x32(self, rhs)
6015    }
6016}
6017impl<S: Simd> core::ops::SubAssign for u16x32<S> {
6018    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
6019    #[inline(always)]
6020    fn sub_assign(&mut self, rhs: Self) {
6021        *self = self.simd.sub_u16x32(*self, rhs);
6022    }
6023}
6024impl<S: Simd> core::ops::Sub<u16> for u16x32<S> {
6025    type Output = Self;
6026    #[inline(always)]
6027    fn sub(self, rhs: u16) -> Self::Output {
6028        self.simd.sub_u16x32(self, rhs.simd_into(self.simd))
6029    }
6030}
6031impl<S: Simd> core::ops::SubAssign<u16> for u16x32<S> {
6032    #[inline(always)]
6033    fn sub_assign(&mut self, rhs: u16) {
6034        *self = self.simd.sub_u16x32(*self, rhs.simd_into(self.simd));
6035    }
6036}
6037impl<S: Simd> core::ops::Sub<u16x32<S>> for u16 {
6038    type Output = u16x32<S>;
6039    #[inline(always)]
6040    fn sub(self, rhs: u16x32<S>) -> Self::Output {
6041        rhs.simd.sub_u16x32(self.simd_into(rhs.simd), rhs)
6042    }
6043}
6044impl<S: Simd> core::ops::Mul for u16x32<S> {
6045    type Output = Self;
6046    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
6047    #[inline(always)]
6048    fn mul(self, rhs: Self) -> Self::Output {
6049        self.simd.mul_u16x32(self, rhs)
6050    }
6051}
6052impl<S: Simd> core::ops::MulAssign for u16x32<S> {
6053    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
6054    #[inline(always)]
6055    fn mul_assign(&mut self, rhs: Self) {
6056        *self = self.simd.mul_u16x32(*self, rhs);
6057    }
6058}
6059impl<S: Simd> core::ops::Mul<u16> for u16x32<S> {
6060    type Output = Self;
6061    #[inline(always)]
6062    fn mul(self, rhs: u16) -> Self::Output {
6063        self.simd.mul_u16x32(self, rhs.simd_into(self.simd))
6064    }
6065}
6066impl<S: Simd> core::ops::MulAssign<u16> for u16x32<S> {
6067    #[inline(always)]
6068    fn mul_assign(&mut self, rhs: u16) {
6069        *self = self.simd.mul_u16x32(*self, rhs.simd_into(self.simd));
6070    }
6071}
6072impl<S: Simd> core::ops::Mul<u16x32<S>> for u16 {
6073    type Output = u16x32<S>;
6074    #[inline(always)]
6075    fn mul(self, rhs: u16x32<S>) -> Self::Output {
6076        rhs.simd.mul_u16x32(self.simd_into(rhs.simd), rhs)
6077    }
6078}
6079impl<S: Simd> core::ops::BitAnd for u16x32<S> {
6080    type Output = Self;
6081    #[doc = "Compute the bitwise AND of two vectors."]
6082    #[inline(always)]
6083    fn bitand(self, rhs: Self) -> Self::Output {
6084        self.simd.and_u16x32(self, rhs)
6085    }
6086}
6087impl<S: Simd> core::ops::BitAndAssign for u16x32<S> {
6088    #[doc = "Compute the bitwise AND of two vectors."]
6089    #[inline(always)]
6090    fn bitand_assign(&mut self, rhs: Self) {
6091        *self = self.simd.and_u16x32(*self, rhs);
6092    }
6093}
6094impl<S: Simd> core::ops::BitAnd<u16> for u16x32<S> {
6095    type Output = Self;
6096    #[inline(always)]
6097    fn bitand(self, rhs: u16) -> Self::Output {
6098        self.simd.and_u16x32(self, rhs.simd_into(self.simd))
6099    }
6100}
6101impl<S: Simd> core::ops::BitAndAssign<u16> for u16x32<S> {
6102    #[inline(always)]
6103    fn bitand_assign(&mut self, rhs: u16) {
6104        *self = self.simd.and_u16x32(*self, rhs.simd_into(self.simd));
6105    }
6106}
6107impl<S: Simd> core::ops::BitAnd<u16x32<S>> for u16 {
6108    type Output = u16x32<S>;
6109    #[inline(always)]
6110    fn bitand(self, rhs: u16x32<S>) -> Self::Output {
6111        rhs.simd.and_u16x32(self.simd_into(rhs.simd), rhs)
6112    }
6113}
6114impl<S: Simd> core::ops::BitOr for u16x32<S> {
6115    type Output = Self;
6116    #[doc = "Compute the bitwise OR of two vectors."]
6117    #[inline(always)]
6118    fn bitor(self, rhs: Self) -> Self::Output {
6119        self.simd.or_u16x32(self, rhs)
6120    }
6121}
6122impl<S: Simd> core::ops::BitOrAssign for u16x32<S> {
6123    #[doc = "Compute the bitwise OR of two vectors."]
6124    #[inline(always)]
6125    fn bitor_assign(&mut self, rhs: Self) {
6126        *self = self.simd.or_u16x32(*self, rhs);
6127    }
6128}
6129impl<S: Simd> core::ops::BitOr<u16> for u16x32<S> {
6130    type Output = Self;
6131    #[inline(always)]
6132    fn bitor(self, rhs: u16) -> Self::Output {
6133        self.simd.or_u16x32(self, rhs.simd_into(self.simd))
6134    }
6135}
6136impl<S: Simd> core::ops::BitOrAssign<u16> for u16x32<S> {
6137    #[inline(always)]
6138    fn bitor_assign(&mut self, rhs: u16) {
6139        *self = self.simd.or_u16x32(*self, rhs.simd_into(self.simd));
6140    }
6141}
6142impl<S: Simd> core::ops::BitOr<u16x32<S>> for u16 {
6143    type Output = u16x32<S>;
6144    #[inline(always)]
6145    fn bitor(self, rhs: u16x32<S>) -> Self::Output {
6146        rhs.simd.or_u16x32(self.simd_into(rhs.simd), rhs)
6147    }
6148}
6149impl<S: Simd> core::ops::BitXor for u16x32<S> {
6150    type Output = Self;
6151    #[doc = "Compute the bitwise XOR of two vectors."]
6152    #[inline(always)]
6153    fn bitxor(self, rhs: Self) -> Self::Output {
6154        self.simd.xor_u16x32(self, rhs)
6155    }
6156}
6157impl<S: Simd> core::ops::BitXorAssign for u16x32<S> {
6158    #[doc = "Compute the bitwise XOR of two vectors."]
6159    #[inline(always)]
6160    fn bitxor_assign(&mut self, rhs: Self) {
6161        *self = self.simd.xor_u16x32(*self, rhs);
6162    }
6163}
6164impl<S: Simd> core::ops::BitXor<u16> for u16x32<S> {
6165    type Output = Self;
6166    #[inline(always)]
6167    fn bitxor(self, rhs: u16) -> Self::Output {
6168        self.simd.xor_u16x32(self, rhs.simd_into(self.simd))
6169    }
6170}
6171impl<S: Simd> core::ops::BitXorAssign<u16> for u16x32<S> {
6172    #[inline(always)]
6173    fn bitxor_assign(&mut self, rhs: u16) {
6174        *self = self.simd.xor_u16x32(*self, rhs.simd_into(self.simd));
6175    }
6176}
6177impl<S: Simd> core::ops::BitXor<u16x32<S>> for u16 {
6178    type Output = u16x32<S>;
6179    #[inline(always)]
6180    fn bitxor(self, rhs: u16x32<S>) -> Self::Output {
6181        rhs.simd.xor_u16x32(self.simd_into(rhs.simd), rhs)
6182    }
6183}
6184impl<S: Simd> core::ops::Not for u16x32<S> {
6185    type Output = Self;
6186    #[doc = "Compute the bitwise NOT of the vector."]
6187    #[inline(always)]
6188    fn not(self) -> Self::Output {
6189        self.simd.not_u16x32(self)
6190    }
6191}
6192impl<S: Simd> core::ops::Shl<u32> for u16x32<S> {
6193    type Output = Self;
6194    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
6195    #[inline(always)]
6196    fn shl(self, rhs: u32) -> Self::Output {
6197        self.simd.shl_u16x32(self, rhs)
6198    }
6199}
6200impl<S: Simd> core::ops::ShlAssign<u32> for u16x32<S> {
6201    #[inline(always)]
6202    fn shl_assign(&mut self, rhs: u32) {
6203        *self = self.simd.shl_u16x32(*self, rhs);
6204    }
6205}
6206impl<S: Simd> core::ops::Shl for u16x32<S> {
6207    type Output = Self;
6208    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6209    #[inline(always)]
6210    fn shl(self, rhs: Self) -> Self::Output {
6211        self.simd.shlv_u16x32(self, rhs)
6212    }
6213}
6214impl<S: Simd> core::ops::ShlAssign for u16x32<S> {
6215    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6216    #[inline(always)]
6217    fn shl_assign(&mut self, rhs: Self) {
6218        *self = self.simd.shlv_u16x32(*self, rhs);
6219    }
6220}
6221impl<S: Simd> core::ops::Shr<u32> for u16x32<S> {
6222    type Output = Self;
6223    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
6224    #[inline(always)]
6225    fn shr(self, rhs: u32) -> Self::Output {
6226        self.simd.shr_u16x32(self, rhs)
6227    }
6228}
6229impl<S: Simd> core::ops::ShrAssign<u32> for u16x32<S> {
6230    #[inline(always)]
6231    fn shr_assign(&mut self, rhs: u32) {
6232        *self = self.simd.shr_u16x32(*self, rhs);
6233    }
6234}
6235impl<S: Simd> core::ops::Shr for u16x32<S> {
6236    type Output = Self;
6237    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6238    #[inline(always)]
6239    fn shr(self, rhs: Self) -> Self::Output {
6240        self.simd.shrv_u16x32(self, rhs)
6241    }
6242}
6243impl<S: Simd> core::ops::ShrAssign for u16x32<S> {
6244    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6245    #[inline(always)]
6246    fn shr_assign(&mut self, rhs: Self) {
6247        *self = self.simd.shrv_u16x32(*self, rhs);
6248    }
6249}
6250impl<S: Simd> core::ops::BitAnd for mask16x32<S> {
6251    type Output = Self;
6252    #[doc = "Compute the logical AND of two masks."]
6253    #[inline(always)]
6254    fn bitand(self, rhs: Self) -> Self::Output {
6255        self.simd.and_mask16x32(self, rhs)
6256    }
6257}
6258impl<S: Simd> core::ops::BitAndAssign for mask16x32<S> {
6259    #[doc = "Compute the logical AND of two masks."]
6260    #[inline(always)]
6261    fn bitand_assign(&mut self, rhs: Self) {
6262        *self = self.simd.and_mask16x32(*self, rhs);
6263    }
6264}
6265impl<S: Simd> core::ops::BitAnd<i16> for mask16x32<S> {
6266    type Output = Self;
6267    #[inline(always)]
6268    fn bitand(self, rhs: i16) -> Self::Output {
6269        self.simd.and_mask16x32(self, rhs.simd_into(self.simd))
6270    }
6271}
6272impl<S: Simd> core::ops::BitAndAssign<i16> for mask16x32<S> {
6273    #[inline(always)]
6274    fn bitand_assign(&mut self, rhs: i16) {
6275        *self = self.simd.and_mask16x32(*self, rhs.simd_into(self.simd));
6276    }
6277}
6278impl<S: Simd> core::ops::BitAnd<mask16x32<S>> for i16 {
6279    type Output = mask16x32<S>;
6280    #[inline(always)]
6281    fn bitand(self, rhs: mask16x32<S>) -> Self::Output {
6282        rhs.simd.and_mask16x32(self.simd_into(rhs.simd), rhs)
6283    }
6284}
6285impl<S: Simd> core::ops::BitOr for mask16x32<S> {
6286    type Output = Self;
6287    #[doc = "Compute the logical OR of two masks."]
6288    #[inline(always)]
6289    fn bitor(self, rhs: Self) -> Self::Output {
6290        self.simd.or_mask16x32(self, rhs)
6291    }
6292}
6293impl<S: Simd> core::ops::BitOrAssign for mask16x32<S> {
6294    #[doc = "Compute the logical OR of two masks."]
6295    #[inline(always)]
6296    fn bitor_assign(&mut self, rhs: Self) {
6297        *self = self.simd.or_mask16x32(*self, rhs);
6298    }
6299}
6300impl<S: Simd> core::ops::BitOr<i16> for mask16x32<S> {
6301    type Output = Self;
6302    #[inline(always)]
6303    fn bitor(self, rhs: i16) -> Self::Output {
6304        self.simd.or_mask16x32(self, rhs.simd_into(self.simd))
6305    }
6306}
6307impl<S: Simd> core::ops::BitOrAssign<i16> for mask16x32<S> {
6308    #[inline(always)]
6309    fn bitor_assign(&mut self, rhs: i16) {
6310        *self = self.simd.or_mask16x32(*self, rhs.simd_into(self.simd));
6311    }
6312}
6313impl<S: Simd> core::ops::BitOr<mask16x32<S>> for i16 {
6314    type Output = mask16x32<S>;
6315    #[inline(always)]
6316    fn bitor(self, rhs: mask16x32<S>) -> Self::Output {
6317        rhs.simd.or_mask16x32(self.simd_into(rhs.simd), rhs)
6318    }
6319}
6320impl<S: Simd> core::ops::BitXor for mask16x32<S> {
6321    type Output = Self;
6322    #[doc = "Compute the logical XOR of two masks."]
6323    #[inline(always)]
6324    fn bitxor(self, rhs: Self) -> Self::Output {
6325        self.simd.xor_mask16x32(self, rhs)
6326    }
6327}
6328impl<S: Simd> core::ops::BitXorAssign for mask16x32<S> {
6329    #[doc = "Compute the logical XOR of two masks."]
6330    #[inline(always)]
6331    fn bitxor_assign(&mut self, rhs: Self) {
6332        *self = self.simd.xor_mask16x32(*self, rhs);
6333    }
6334}
6335impl<S: Simd> core::ops::BitXor<i16> for mask16x32<S> {
6336    type Output = Self;
6337    #[inline(always)]
6338    fn bitxor(self, rhs: i16) -> Self::Output {
6339        self.simd.xor_mask16x32(self, rhs.simd_into(self.simd))
6340    }
6341}
6342impl<S: Simd> core::ops::BitXorAssign<i16> for mask16x32<S> {
6343    #[inline(always)]
6344    fn bitxor_assign(&mut self, rhs: i16) {
6345        *self = self.simd.xor_mask16x32(*self, rhs.simd_into(self.simd));
6346    }
6347}
6348impl<S: Simd> core::ops::BitXor<mask16x32<S>> for i16 {
6349    type Output = mask16x32<S>;
6350    #[inline(always)]
6351    fn bitxor(self, rhs: mask16x32<S>) -> Self::Output {
6352        rhs.simd.xor_mask16x32(self.simd_into(rhs.simd), rhs)
6353    }
6354}
6355impl<S: Simd> core::ops::Not for mask16x32<S> {
6356    type Output = Self;
6357    #[doc = "Compute the logical NOT of the mask."]
6358    #[inline(always)]
6359    fn not(self) -> Self::Output {
6360        self.simd.not_mask16x32(self)
6361    }
6362}
6363impl<S: Simd> core::ops::Neg for i32x16<S> {
6364    type Output = Self;
6365    #[doc = "Negate each element of the vector, wrapping on overflow."]
6366    #[inline(always)]
6367    fn neg(self) -> Self::Output {
6368        self.simd.neg_i32x16(self)
6369    }
6370}
6371impl<S: Simd> core::ops::Add for i32x16<S> {
6372    type Output = Self;
6373    #[doc = "Add two vectors element-wise, wrapping on overflow."]
6374    #[inline(always)]
6375    fn add(self, rhs: Self) -> Self::Output {
6376        self.simd.add_i32x16(self, rhs)
6377    }
6378}
6379impl<S: Simd> core::ops::AddAssign for i32x16<S> {
6380    #[doc = "Add two vectors element-wise, wrapping on overflow."]
6381    #[inline(always)]
6382    fn add_assign(&mut self, rhs: Self) {
6383        *self = self.simd.add_i32x16(*self, rhs);
6384    }
6385}
6386impl<S: Simd> core::ops::Add<i32> for i32x16<S> {
6387    type Output = Self;
6388    #[inline(always)]
6389    fn add(self, rhs: i32) -> Self::Output {
6390        self.simd.add_i32x16(self, rhs.simd_into(self.simd))
6391    }
6392}
6393impl<S: Simd> core::ops::AddAssign<i32> for i32x16<S> {
6394    #[inline(always)]
6395    fn add_assign(&mut self, rhs: i32) {
6396        *self = self.simd.add_i32x16(*self, rhs.simd_into(self.simd));
6397    }
6398}
6399impl<S: Simd> core::ops::Add<i32x16<S>> for i32 {
6400    type Output = i32x16<S>;
6401    #[inline(always)]
6402    fn add(self, rhs: i32x16<S>) -> Self::Output {
6403        rhs.simd.add_i32x16(self.simd_into(rhs.simd), rhs)
6404    }
6405}
6406impl<S: Simd> core::ops::Sub for i32x16<S> {
6407    type Output = Self;
6408    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
6409    #[inline(always)]
6410    fn sub(self, rhs: Self) -> Self::Output {
6411        self.simd.sub_i32x16(self, rhs)
6412    }
6413}
6414impl<S: Simd> core::ops::SubAssign for i32x16<S> {
6415    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
6416    #[inline(always)]
6417    fn sub_assign(&mut self, rhs: Self) {
6418        *self = self.simd.sub_i32x16(*self, rhs);
6419    }
6420}
6421impl<S: Simd> core::ops::Sub<i32> for i32x16<S> {
6422    type Output = Self;
6423    #[inline(always)]
6424    fn sub(self, rhs: i32) -> Self::Output {
6425        self.simd.sub_i32x16(self, rhs.simd_into(self.simd))
6426    }
6427}
6428impl<S: Simd> core::ops::SubAssign<i32> for i32x16<S> {
6429    #[inline(always)]
6430    fn sub_assign(&mut self, rhs: i32) {
6431        *self = self.simd.sub_i32x16(*self, rhs.simd_into(self.simd));
6432    }
6433}
6434impl<S: Simd> core::ops::Sub<i32x16<S>> for i32 {
6435    type Output = i32x16<S>;
6436    #[inline(always)]
6437    fn sub(self, rhs: i32x16<S>) -> Self::Output {
6438        rhs.simd.sub_i32x16(self.simd_into(rhs.simd), rhs)
6439    }
6440}
6441impl<S: Simd> core::ops::Mul for i32x16<S> {
6442    type Output = Self;
6443    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
6444    #[inline(always)]
6445    fn mul(self, rhs: Self) -> Self::Output {
6446        self.simd.mul_i32x16(self, rhs)
6447    }
6448}
6449impl<S: Simd> core::ops::MulAssign for i32x16<S> {
6450    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
6451    #[inline(always)]
6452    fn mul_assign(&mut self, rhs: Self) {
6453        *self = self.simd.mul_i32x16(*self, rhs);
6454    }
6455}
6456impl<S: Simd> core::ops::Mul<i32> for i32x16<S> {
6457    type Output = Self;
6458    #[inline(always)]
6459    fn mul(self, rhs: i32) -> Self::Output {
6460        self.simd.mul_i32x16(self, rhs.simd_into(self.simd))
6461    }
6462}
6463impl<S: Simd> core::ops::MulAssign<i32> for i32x16<S> {
6464    #[inline(always)]
6465    fn mul_assign(&mut self, rhs: i32) {
6466        *self = self.simd.mul_i32x16(*self, rhs.simd_into(self.simd));
6467    }
6468}
6469impl<S: Simd> core::ops::Mul<i32x16<S>> for i32 {
6470    type Output = i32x16<S>;
6471    #[inline(always)]
6472    fn mul(self, rhs: i32x16<S>) -> Self::Output {
6473        rhs.simd.mul_i32x16(self.simd_into(rhs.simd), rhs)
6474    }
6475}
6476impl<S: Simd> core::ops::BitAnd for i32x16<S> {
6477    type Output = Self;
6478    #[doc = "Compute the bitwise AND of two vectors."]
6479    #[inline(always)]
6480    fn bitand(self, rhs: Self) -> Self::Output {
6481        self.simd.and_i32x16(self, rhs)
6482    }
6483}
6484impl<S: Simd> core::ops::BitAndAssign for i32x16<S> {
6485    #[doc = "Compute the bitwise AND of two vectors."]
6486    #[inline(always)]
6487    fn bitand_assign(&mut self, rhs: Self) {
6488        *self = self.simd.and_i32x16(*self, rhs);
6489    }
6490}
6491impl<S: Simd> core::ops::BitAnd<i32> for i32x16<S> {
6492    type Output = Self;
6493    #[inline(always)]
6494    fn bitand(self, rhs: i32) -> Self::Output {
6495        self.simd.and_i32x16(self, rhs.simd_into(self.simd))
6496    }
6497}
6498impl<S: Simd> core::ops::BitAndAssign<i32> for i32x16<S> {
6499    #[inline(always)]
6500    fn bitand_assign(&mut self, rhs: i32) {
6501        *self = self.simd.and_i32x16(*self, rhs.simd_into(self.simd));
6502    }
6503}
6504impl<S: Simd> core::ops::BitAnd<i32x16<S>> for i32 {
6505    type Output = i32x16<S>;
6506    #[inline(always)]
6507    fn bitand(self, rhs: i32x16<S>) -> Self::Output {
6508        rhs.simd.and_i32x16(self.simd_into(rhs.simd), rhs)
6509    }
6510}
6511impl<S: Simd> core::ops::BitOr for i32x16<S> {
6512    type Output = Self;
6513    #[doc = "Compute the bitwise OR of two vectors."]
6514    #[inline(always)]
6515    fn bitor(self, rhs: Self) -> Self::Output {
6516        self.simd.or_i32x16(self, rhs)
6517    }
6518}
6519impl<S: Simd> core::ops::BitOrAssign for i32x16<S> {
6520    #[doc = "Compute the bitwise OR of two vectors."]
6521    #[inline(always)]
6522    fn bitor_assign(&mut self, rhs: Self) {
6523        *self = self.simd.or_i32x16(*self, rhs);
6524    }
6525}
6526impl<S: Simd> core::ops::BitOr<i32> for i32x16<S> {
6527    type Output = Self;
6528    #[inline(always)]
6529    fn bitor(self, rhs: i32) -> Self::Output {
6530        self.simd.or_i32x16(self, rhs.simd_into(self.simd))
6531    }
6532}
6533impl<S: Simd> core::ops::BitOrAssign<i32> for i32x16<S> {
6534    #[inline(always)]
6535    fn bitor_assign(&mut self, rhs: i32) {
6536        *self = self.simd.or_i32x16(*self, rhs.simd_into(self.simd));
6537    }
6538}
6539impl<S: Simd> core::ops::BitOr<i32x16<S>> for i32 {
6540    type Output = i32x16<S>;
6541    #[inline(always)]
6542    fn bitor(self, rhs: i32x16<S>) -> Self::Output {
6543        rhs.simd.or_i32x16(self.simd_into(rhs.simd), rhs)
6544    }
6545}
6546impl<S: Simd> core::ops::BitXor for i32x16<S> {
6547    type Output = Self;
6548    #[doc = "Compute the bitwise XOR of two vectors."]
6549    #[inline(always)]
6550    fn bitxor(self, rhs: Self) -> Self::Output {
6551        self.simd.xor_i32x16(self, rhs)
6552    }
6553}
6554impl<S: Simd> core::ops::BitXorAssign for i32x16<S> {
6555    #[doc = "Compute the bitwise XOR of two vectors."]
6556    #[inline(always)]
6557    fn bitxor_assign(&mut self, rhs: Self) {
6558        *self = self.simd.xor_i32x16(*self, rhs);
6559    }
6560}
6561impl<S: Simd> core::ops::BitXor<i32> for i32x16<S> {
6562    type Output = Self;
6563    #[inline(always)]
6564    fn bitxor(self, rhs: i32) -> Self::Output {
6565        self.simd.xor_i32x16(self, rhs.simd_into(self.simd))
6566    }
6567}
6568impl<S: Simd> core::ops::BitXorAssign<i32> for i32x16<S> {
6569    #[inline(always)]
6570    fn bitxor_assign(&mut self, rhs: i32) {
6571        *self = self.simd.xor_i32x16(*self, rhs.simd_into(self.simd));
6572    }
6573}
6574impl<S: Simd> core::ops::BitXor<i32x16<S>> for i32 {
6575    type Output = i32x16<S>;
6576    #[inline(always)]
6577    fn bitxor(self, rhs: i32x16<S>) -> Self::Output {
6578        rhs.simd.xor_i32x16(self.simd_into(rhs.simd), rhs)
6579    }
6580}
6581impl<S: Simd> core::ops::Not for i32x16<S> {
6582    type Output = Self;
6583    #[doc = "Compute the bitwise NOT of the vector."]
6584    #[inline(always)]
6585    fn not(self) -> Self::Output {
6586        self.simd.not_i32x16(self)
6587    }
6588}
6589impl<S: Simd> core::ops::Shl<u32> for i32x16<S> {
6590    type Output = Self;
6591    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
6592    #[inline(always)]
6593    fn shl(self, rhs: u32) -> Self::Output {
6594        self.simd.shl_i32x16(self, rhs)
6595    }
6596}
6597impl<S: Simd> core::ops::ShlAssign<u32> for i32x16<S> {
6598    #[inline(always)]
6599    fn shl_assign(&mut self, rhs: u32) {
6600        *self = self.simd.shl_i32x16(*self, rhs);
6601    }
6602}
6603impl<S: Simd> core::ops::Shl for i32x16<S> {
6604    type Output = Self;
6605    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6606    #[inline(always)]
6607    fn shl(self, rhs: Self) -> Self::Output {
6608        self.simd.shlv_i32x16(self, rhs)
6609    }
6610}
6611impl<S: Simd> core::ops::ShlAssign for i32x16<S> {
6612    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6613    #[inline(always)]
6614    fn shl_assign(&mut self, rhs: Self) {
6615        *self = self.simd.shlv_i32x16(*self, rhs);
6616    }
6617}
6618impl<S: Simd> core::ops::Shr<u32> for i32x16<S> {
6619    type Output = Self;
6620    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
6621    #[inline(always)]
6622    fn shr(self, rhs: u32) -> Self::Output {
6623        self.simd.shr_i32x16(self, rhs)
6624    }
6625}
6626impl<S: Simd> core::ops::ShrAssign<u32> for i32x16<S> {
6627    #[inline(always)]
6628    fn shr_assign(&mut self, rhs: u32) {
6629        *self = self.simd.shr_i32x16(*self, rhs);
6630    }
6631}
6632impl<S: Simd> core::ops::Shr for i32x16<S> {
6633    type Output = Self;
6634    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6635    #[inline(always)]
6636    fn shr(self, rhs: Self) -> Self::Output {
6637        self.simd.shrv_i32x16(self, rhs)
6638    }
6639}
6640impl<S: Simd> core::ops::ShrAssign for i32x16<S> {
6641    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6642    #[inline(always)]
6643    fn shr_assign(&mut self, rhs: Self) {
6644        *self = self.simd.shrv_i32x16(*self, rhs);
6645    }
6646}
6647impl<S: Simd> core::ops::Add for u32x16<S> {
6648    type Output = Self;
6649    #[doc = "Add two vectors element-wise, wrapping on overflow."]
6650    #[inline(always)]
6651    fn add(self, rhs: Self) -> Self::Output {
6652        self.simd.add_u32x16(self, rhs)
6653    }
6654}
6655impl<S: Simd> core::ops::AddAssign for u32x16<S> {
6656    #[doc = "Add two vectors element-wise, wrapping on overflow."]
6657    #[inline(always)]
6658    fn add_assign(&mut self, rhs: Self) {
6659        *self = self.simd.add_u32x16(*self, rhs);
6660    }
6661}
6662impl<S: Simd> core::ops::Add<u32> for u32x16<S> {
6663    type Output = Self;
6664    #[inline(always)]
6665    fn add(self, rhs: u32) -> Self::Output {
6666        self.simd.add_u32x16(self, rhs.simd_into(self.simd))
6667    }
6668}
6669impl<S: Simd> core::ops::AddAssign<u32> for u32x16<S> {
6670    #[inline(always)]
6671    fn add_assign(&mut self, rhs: u32) {
6672        *self = self.simd.add_u32x16(*self, rhs.simd_into(self.simd));
6673    }
6674}
6675impl<S: Simd> core::ops::Add<u32x16<S>> for u32 {
6676    type Output = u32x16<S>;
6677    #[inline(always)]
6678    fn add(self, rhs: u32x16<S>) -> Self::Output {
6679        rhs.simd.add_u32x16(self.simd_into(rhs.simd), rhs)
6680    }
6681}
6682impl<S: Simd> core::ops::Sub for u32x16<S> {
6683    type Output = Self;
6684    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
6685    #[inline(always)]
6686    fn sub(self, rhs: Self) -> Self::Output {
6687        self.simd.sub_u32x16(self, rhs)
6688    }
6689}
6690impl<S: Simd> core::ops::SubAssign for u32x16<S> {
6691    #[doc = "Subtract two vectors element-wise, wrapping on overflow."]
6692    #[inline(always)]
6693    fn sub_assign(&mut self, rhs: Self) {
6694        *self = self.simd.sub_u32x16(*self, rhs);
6695    }
6696}
6697impl<S: Simd> core::ops::Sub<u32> for u32x16<S> {
6698    type Output = Self;
6699    #[inline(always)]
6700    fn sub(self, rhs: u32) -> Self::Output {
6701        self.simd.sub_u32x16(self, rhs.simd_into(self.simd))
6702    }
6703}
6704impl<S: Simd> core::ops::SubAssign<u32> for u32x16<S> {
6705    #[inline(always)]
6706    fn sub_assign(&mut self, rhs: u32) {
6707        *self = self.simd.sub_u32x16(*self, rhs.simd_into(self.simd));
6708    }
6709}
6710impl<S: Simd> core::ops::Sub<u32x16<S>> for u32 {
6711    type Output = u32x16<S>;
6712    #[inline(always)]
6713    fn sub(self, rhs: u32x16<S>) -> Self::Output {
6714        rhs.simd.sub_u32x16(self.simd_into(rhs.simd), rhs)
6715    }
6716}
6717impl<S: Simd> core::ops::Mul for u32x16<S> {
6718    type Output = Self;
6719    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
6720    #[inline(always)]
6721    fn mul(self, rhs: Self) -> Self::Output {
6722        self.simd.mul_u32x16(self, rhs)
6723    }
6724}
6725impl<S: Simd> core::ops::MulAssign for u32x16<S> {
6726    #[doc = "Multiply two vectors element-wise, wrapping on overflow."]
6727    #[inline(always)]
6728    fn mul_assign(&mut self, rhs: Self) {
6729        *self = self.simd.mul_u32x16(*self, rhs);
6730    }
6731}
6732impl<S: Simd> core::ops::Mul<u32> for u32x16<S> {
6733    type Output = Self;
6734    #[inline(always)]
6735    fn mul(self, rhs: u32) -> Self::Output {
6736        self.simd.mul_u32x16(self, rhs.simd_into(self.simd))
6737    }
6738}
6739impl<S: Simd> core::ops::MulAssign<u32> for u32x16<S> {
6740    #[inline(always)]
6741    fn mul_assign(&mut self, rhs: u32) {
6742        *self = self.simd.mul_u32x16(*self, rhs.simd_into(self.simd));
6743    }
6744}
6745impl<S: Simd> core::ops::Mul<u32x16<S>> for u32 {
6746    type Output = u32x16<S>;
6747    #[inline(always)]
6748    fn mul(self, rhs: u32x16<S>) -> Self::Output {
6749        rhs.simd.mul_u32x16(self.simd_into(rhs.simd), rhs)
6750    }
6751}
6752impl<S: Simd> core::ops::BitAnd for u32x16<S> {
6753    type Output = Self;
6754    #[doc = "Compute the bitwise AND of two vectors."]
6755    #[inline(always)]
6756    fn bitand(self, rhs: Self) -> Self::Output {
6757        self.simd.and_u32x16(self, rhs)
6758    }
6759}
6760impl<S: Simd> core::ops::BitAndAssign for u32x16<S> {
6761    #[doc = "Compute the bitwise AND of two vectors."]
6762    #[inline(always)]
6763    fn bitand_assign(&mut self, rhs: Self) {
6764        *self = self.simd.and_u32x16(*self, rhs);
6765    }
6766}
6767impl<S: Simd> core::ops::BitAnd<u32> for u32x16<S> {
6768    type Output = Self;
6769    #[inline(always)]
6770    fn bitand(self, rhs: u32) -> Self::Output {
6771        self.simd.and_u32x16(self, rhs.simd_into(self.simd))
6772    }
6773}
6774impl<S: Simd> core::ops::BitAndAssign<u32> for u32x16<S> {
6775    #[inline(always)]
6776    fn bitand_assign(&mut self, rhs: u32) {
6777        *self = self.simd.and_u32x16(*self, rhs.simd_into(self.simd));
6778    }
6779}
6780impl<S: Simd> core::ops::BitAnd<u32x16<S>> for u32 {
6781    type Output = u32x16<S>;
6782    #[inline(always)]
6783    fn bitand(self, rhs: u32x16<S>) -> Self::Output {
6784        rhs.simd.and_u32x16(self.simd_into(rhs.simd), rhs)
6785    }
6786}
6787impl<S: Simd> core::ops::BitOr for u32x16<S> {
6788    type Output = Self;
6789    #[doc = "Compute the bitwise OR of two vectors."]
6790    #[inline(always)]
6791    fn bitor(self, rhs: Self) -> Self::Output {
6792        self.simd.or_u32x16(self, rhs)
6793    }
6794}
6795impl<S: Simd> core::ops::BitOrAssign for u32x16<S> {
6796    #[doc = "Compute the bitwise OR of two vectors."]
6797    #[inline(always)]
6798    fn bitor_assign(&mut self, rhs: Self) {
6799        *self = self.simd.or_u32x16(*self, rhs);
6800    }
6801}
6802impl<S: Simd> core::ops::BitOr<u32> for u32x16<S> {
6803    type Output = Self;
6804    #[inline(always)]
6805    fn bitor(self, rhs: u32) -> Self::Output {
6806        self.simd.or_u32x16(self, rhs.simd_into(self.simd))
6807    }
6808}
6809impl<S: Simd> core::ops::BitOrAssign<u32> for u32x16<S> {
6810    #[inline(always)]
6811    fn bitor_assign(&mut self, rhs: u32) {
6812        *self = self.simd.or_u32x16(*self, rhs.simd_into(self.simd));
6813    }
6814}
6815impl<S: Simd> core::ops::BitOr<u32x16<S>> for u32 {
6816    type Output = u32x16<S>;
6817    #[inline(always)]
6818    fn bitor(self, rhs: u32x16<S>) -> Self::Output {
6819        rhs.simd.or_u32x16(self.simd_into(rhs.simd), rhs)
6820    }
6821}
6822impl<S: Simd> core::ops::BitXor for u32x16<S> {
6823    type Output = Self;
6824    #[doc = "Compute the bitwise XOR of two vectors."]
6825    #[inline(always)]
6826    fn bitxor(self, rhs: Self) -> Self::Output {
6827        self.simd.xor_u32x16(self, rhs)
6828    }
6829}
6830impl<S: Simd> core::ops::BitXorAssign for u32x16<S> {
6831    #[doc = "Compute the bitwise XOR of two vectors."]
6832    #[inline(always)]
6833    fn bitxor_assign(&mut self, rhs: Self) {
6834        *self = self.simd.xor_u32x16(*self, rhs);
6835    }
6836}
6837impl<S: Simd> core::ops::BitXor<u32> for u32x16<S> {
6838    type Output = Self;
6839    #[inline(always)]
6840    fn bitxor(self, rhs: u32) -> Self::Output {
6841        self.simd.xor_u32x16(self, rhs.simd_into(self.simd))
6842    }
6843}
6844impl<S: Simd> core::ops::BitXorAssign<u32> for u32x16<S> {
6845    #[inline(always)]
6846    fn bitxor_assign(&mut self, rhs: u32) {
6847        *self = self.simd.xor_u32x16(*self, rhs.simd_into(self.simd));
6848    }
6849}
6850impl<S: Simd> core::ops::BitXor<u32x16<S>> for u32 {
6851    type Output = u32x16<S>;
6852    #[inline(always)]
6853    fn bitxor(self, rhs: u32x16<S>) -> Self::Output {
6854        rhs.simd.xor_u32x16(self.simd_into(rhs.simd), rhs)
6855    }
6856}
6857impl<S: Simd> core::ops::Not for u32x16<S> {
6858    type Output = Self;
6859    #[doc = "Compute the bitwise NOT of the vector."]
6860    #[inline(always)]
6861    fn not(self) -> Self::Output {
6862        self.simd.not_u32x16(self)
6863    }
6864}
6865impl<S: Simd> core::ops::Shl<u32> for u32x16<S> {
6866    type Output = Self;
6867    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right."]
6868    #[inline(always)]
6869    fn shl(self, rhs: u32) -> Self::Output {
6870        self.simd.shl_u32x16(self, rhs)
6871    }
6872}
6873impl<S: Simd> core::ops::ShlAssign<u32> for u32x16<S> {
6874    #[inline(always)]
6875    fn shl_assign(&mut self, rhs: u32) {
6876        *self = self.simd.shl_u32x16(*self, rhs);
6877    }
6878}
6879impl<S: Simd> core::ops::Shl for u32x16<S> {
6880    type Output = Self;
6881    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6882    #[inline(always)]
6883    fn shl(self, rhs: Self) -> Self::Output {
6884        self.simd.shlv_u32x16(self, rhs)
6885    }
6886}
6887impl<S: Simd> core::ops::ShlAssign for u32x16<S> {
6888    #[doc = "Shift each element left by the given number of bits.\n\nBits shifted out of the left side are discarded, and zeros are shifted in on the right.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6889    #[inline(always)]
6890    fn shl_assign(&mut self, rhs: Self) {
6891        *self = self.simd.shlv_u32x16(*self, rhs);
6892    }
6893}
6894impl<S: Simd> core::ops::Shr<u32> for u32x16<S> {
6895    type Output = Self;
6896    #[doc = "Shift each element right by the given number of bits.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated."]
6897    #[inline(always)]
6898    fn shr(self, rhs: u32) -> Self::Output {
6899        self.simd.shr_u32x16(self, rhs)
6900    }
6901}
6902impl<S: Simd> core::ops::ShrAssign<u32> for u32x16<S> {
6903    #[inline(always)]
6904    fn shr_assign(&mut self, rhs: u32) {
6905        *self = self.simd.shr_u32x16(*self, rhs);
6906    }
6907}
6908impl<S: Simd> core::ops::Shr for u32x16<S> {
6909    type Output = Self;
6910    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6911    #[inline(always)]
6912    fn shr(self, rhs: Self) -> Self::Output {
6913        self.simd.shrv_u32x16(self, rhs)
6914    }
6915}
6916impl<S: Simd> core::ops::ShrAssign for u32x16<S> {
6917    #[doc = "Shift each element right by the corresponding element in another vector.\n\nFor unsigned integers, zeros are shifted in on the left. For signed integers, the sign bit is replicated.\n\nThis operation is not implemented in hardware on all platforms. On WebAssembly, and on x86 platforms without AVX2, this will use a fallback scalar implementation."]
6918    #[inline(always)]
6919    fn shr_assign(&mut self, rhs: Self) {
6920        *self = self.simd.shrv_u32x16(*self, rhs);
6921    }
6922}
6923impl<S: Simd> core::ops::BitAnd for mask32x16<S> {
6924    type Output = Self;
6925    #[doc = "Compute the logical AND of two masks."]
6926    #[inline(always)]
6927    fn bitand(self, rhs: Self) -> Self::Output {
6928        self.simd.and_mask32x16(self, rhs)
6929    }
6930}
6931impl<S: Simd> core::ops::BitAndAssign for mask32x16<S> {
6932    #[doc = "Compute the logical AND of two masks."]
6933    #[inline(always)]
6934    fn bitand_assign(&mut self, rhs: Self) {
6935        *self = self.simd.and_mask32x16(*self, rhs);
6936    }
6937}
6938impl<S: Simd> core::ops::BitAnd<i32> for mask32x16<S> {
6939    type Output = Self;
6940    #[inline(always)]
6941    fn bitand(self, rhs: i32) -> Self::Output {
6942        self.simd.and_mask32x16(self, rhs.simd_into(self.simd))
6943    }
6944}
6945impl<S: Simd> core::ops::BitAndAssign<i32> for mask32x16<S> {
6946    #[inline(always)]
6947    fn bitand_assign(&mut self, rhs: i32) {
6948        *self = self.simd.and_mask32x16(*self, rhs.simd_into(self.simd));
6949    }
6950}
6951impl<S: Simd> core::ops::BitAnd<mask32x16<S>> for i32 {
6952    type Output = mask32x16<S>;
6953    #[inline(always)]
6954    fn bitand(self, rhs: mask32x16<S>) -> Self::Output {
6955        rhs.simd.and_mask32x16(self.simd_into(rhs.simd), rhs)
6956    }
6957}
6958impl<S: Simd> core::ops::BitOr for mask32x16<S> {
6959    type Output = Self;
6960    #[doc = "Compute the logical OR of two masks."]
6961    #[inline(always)]
6962    fn bitor(self, rhs: Self) -> Self::Output {
6963        self.simd.or_mask32x16(self, rhs)
6964    }
6965}
6966impl<S: Simd> core::ops::BitOrAssign for mask32x16<S> {
6967    #[doc = "Compute the logical OR of two masks."]
6968    #[inline(always)]
6969    fn bitor_assign(&mut self, rhs: Self) {
6970        *self = self.simd.or_mask32x16(*self, rhs);
6971    }
6972}
6973impl<S: Simd> core::ops::BitOr<i32> for mask32x16<S> {
6974    type Output = Self;
6975    #[inline(always)]
6976    fn bitor(self, rhs: i32) -> Self::Output {
6977        self.simd.or_mask32x16(self, rhs.simd_into(self.simd))
6978    }
6979}
6980impl<S: Simd> core::ops::BitOrAssign<i32> for mask32x16<S> {
6981    #[inline(always)]
6982    fn bitor_assign(&mut self, rhs: i32) {
6983        *self = self.simd.or_mask32x16(*self, rhs.simd_into(self.simd));
6984    }
6985}
6986impl<S: Simd> core::ops::BitOr<mask32x16<S>> for i32 {
6987    type Output = mask32x16<S>;
6988    #[inline(always)]
6989    fn bitor(self, rhs: mask32x16<S>) -> Self::Output {
6990        rhs.simd.or_mask32x16(self.simd_into(rhs.simd), rhs)
6991    }
6992}
6993impl<S: Simd> core::ops::BitXor for mask32x16<S> {
6994    type Output = Self;
6995    #[doc = "Compute the logical XOR of two masks."]
6996    #[inline(always)]
6997    fn bitxor(self, rhs: Self) -> Self::Output {
6998        self.simd.xor_mask32x16(self, rhs)
6999    }
7000}
7001impl<S: Simd> core::ops::BitXorAssign for mask32x16<S> {
7002    #[doc = "Compute the logical XOR of two masks."]
7003    #[inline(always)]
7004    fn bitxor_assign(&mut self, rhs: Self) {
7005        *self = self.simd.xor_mask32x16(*self, rhs);
7006    }
7007}
7008impl<S: Simd> core::ops::BitXor<i32> for mask32x16<S> {
7009    type Output = Self;
7010    #[inline(always)]
7011    fn bitxor(self, rhs: i32) -> Self::Output {
7012        self.simd.xor_mask32x16(self, rhs.simd_into(self.simd))
7013    }
7014}
7015impl<S: Simd> core::ops::BitXorAssign<i32> for mask32x16<S> {
7016    #[inline(always)]
7017    fn bitxor_assign(&mut self, rhs: i32) {
7018        *self = self.simd.xor_mask32x16(*self, rhs.simd_into(self.simd));
7019    }
7020}
7021impl<S: Simd> core::ops::BitXor<mask32x16<S>> for i32 {
7022    type Output = mask32x16<S>;
7023    #[inline(always)]
7024    fn bitxor(self, rhs: mask32x16<S>) -> Self::Output {
7025        rhs.simd.xor_mask32x16(self.simd_into(rhs.simd), rhs)
7026    }
7027}
7028impl<S: Simd> core::ops::Not for mask32x16<S> {
7029    type Output = Self;
7030    #[doc = "Compute the logical NOT of the mask."]
7031    #[inline(always)]
7032    fn not(self) -> Self::Output {
7033        self.simd.not_mask32x16(self)
7034    }
7035}
7036impl<S: Simd> core::ops::Neg for f64x8<S> {
7037    type Output = Self;
7038    #[doc = "Negate each element of the vector."]
7039    #[inline(always)]
7040    fn neg(self) -> Self::Output {
7041        self.simd.neg_f64x8(self)
7042    }
7043}
7044impl<S: Simd> core::ops::Add for f64x8<S> {
7045    type Output = Self;
7046    #[doc = "Add two vectors element-wise."]
7047    #[inline(always)]
7048    fn add(self, rhs: Self) -> Self::Output {
7049        self.simd.add_f64x8(self, rhs)
7050    }
7051}
7052impl<S: Simd> core::ops::AddAssign for f64x8<S> {
7053    #[doc = "Add two vectors element-wise."]
7054    #[inline(always)]
7055    fn add_assign(&mut self, rhs: Self) {
7056        *self = self.simd.add_f64x8(*self, rhs);
7057    }
7058}
7059impl<S: Simd> core::ops::Add<f64> for f64x8<S> {
7060    type Output = Self;
7061    #[inline(always)]
7062    fn add(self, rhs: f64) -> Self::Output {
7063        self.simd.add_f64x8(self, rhs.simd_into(self.simd))
7064    }
7065}
7066impl<S: Simd> core::ops::AddAssign<f64> for f64x8<S> {
7067    #[inline(always)]
7068    fn add_assign(&mut self, rhs: f64) {
7069        *self = self.simd.add_f64x8(*self, rhs.simd_into(self.simd));
7070    }
7071}
7072impl<S: Simd> core::ops::Add<f64x8<S>> for f64 {
7073    type Output = f64x8<S>;
7074    #[inline(always)]
7075    fn add(self, rhs: f64x8<S>) -> Self::Output {
7076        rhs.simd.add_f64x8(self.simd_into(rhs.simd), rhs)
7077    }
7078}
7079impl<S: Simd> core::ops::Sub for f64x8<S> {
7080    type Output = Self;
7081    #[doc = "Subtract two vectors element-wise."]
7082    #[inline(always)]
7083    fn sub(self, rhs: Self) -> Self::Output {
7084        self.simd.sub_f64x8(self, rhs)
7085    }
7086}
7087impl<S: Simd> core::ops::SubAssign for f64x8<S> {
7088    #[doc = "Subtract two vectors element-wise."]
7089    #[inline(always)]
7090    fn sub_assign(&mut self, rhs: Self) {
7091        *self = self.simd.sub_f64x8(*self, rhs);
7092    }
7093}
7094impl<S: Simd> core::ops::Sub<f64> for f64x8<S> {
7095    type Output = Self;
7096    #[inline(always)]
7097    fn sub(self, rhs: f64) -> Self::Output {
7098        self.simd.sub_f64x8(self, rhs.simd_into(self.simd))
7099    }
7100}
7101impl<S: Simd> core::ops::SubAssign<f64> for f64x8<S> {
7102    #[inline(always)]
7103    fn sub_assign(&mut self, rhs: f64) {
7104        *self = self.simd.sub_f64x8(*self, rhs.simd_into(self.simd));
7105    }
7106}
7107impl<S: Simd> core::ops::Sub<f64x8<S>> for f64 {
7108    type Output = f64x8<S>;
7109    #[inline(always)]
7110    fn sub(self, rhs: f64x8<S>) -> Self::Output {
7111        rhs.simd.sub_f64x8(self.simd_into(rhs.simd), rhs)
7112    }
7113}
7114impl<S: Simd> core::ops::Mul for f64x8<S> {
7115    type Output = Self;
7116    #[doc = "Multiply two vectors element-wise."]
7117    #[inline(always)]
7118    fn mul(self, rhs: Self) -> Self::Output {
7119        self.simd.mul_f64x8(self, rhs)
7120    }
7121}
7122impl<S: Simd> core::ops::MulAssign for f64x8<S> {
7123    #[doc = "Multiply two vectors element-wise."]
7124    #[inline(always)]
7125    fn mul_assign(&mut self, rhs: Self) {
7126        *self = self.simd.mul_f64x8(*self, rhs);
7127    }
7128}
7129impl<S: Simd> core::ops::Mul<f64> for f64x8<S> {
7130    type Output = Self;
7131    #[inline(always)]
7132    fn mul(self, rhs: f64) -> Self::Output {
7133        self.simd.mul_f64x8(self, rhs.simd_into(self.simd))
7134    }
7135}
7136impl<S: Simd> core::ops::MulAssign<f64> for f64x8<S> {
7137    #[inline(always)]
7138    fn mul_assign(&mut self, rhs: f64) {
7139        *self = self.simd.mul_f64x8(*self, rhs.simd_into(self.simd));
7140    }
7141}
7142impl<S: Simd> core::ops::Mul<f64x8<S>> for f64 {
7143    type Output = f64x8<S>;
7144    #[inline(always)]
7145    fn mul(self, rhs: f64x8<S>) -> Self::Output {
7146        rhs.simd.mul_f64x8(self.simd_into(rhs.simd), rhs)
7147    }
7148}
7149impl<S: Simd> core::ops::Div for f64x8<S> {
7150    type Output = Self;
7151    #[doc = "Divide two vectors element-wise."]
7152    #[inline(always)]
7153    fn div(self, rhs: Self) -> Self::Output {
7154        self.simd.div_f64x8(self, rhs)
7155    }
7156}
7157impl<S: Simd> core::ops::DivAssign for f64x8<S> {
7158    #[doc = "Divide two vectors element-wise."]
7159    #[inline(always)]
7160    fn div_assign(&mut self, rhs: Self) {
7161        *self = self.simd.div_f64x8(*self, rhs);
7162    }
7163}
7164impl<S: Simd> core::ops::Div<f64> for f64x8<S> {
7165    type Output = Self;
7166    #[inline(always)]
7167    fn div(self, rhs: f64) -> Self::Output {
7168        self.simd.div_f64x8(self, rhs.simd_into(self.simd))
7169    }
7170}
7171impl<S: Simd> core::ops::DivAssign<f64> for f64x8<S> {
7172    #[inline(always)]
7173    fn div_assign(&mut self, rhs: f64) {
7174        *self = self.simd.div_f64x8(*self, rhs.simd_into(self.simd));
7175    }
7176}
7177impl<S: Simd> core::ops::Div<f64x8<S>> for f64 {
7178    type Output = f64x8<S>;
7179    #[inline(always)]
7180    fn div(self, rhs: f64x8<S>) -> Self::Output {
7181        rhs.simd.div_f64x8(self.simd_into(rhs.simd), rhs)
7182    }
7183}
7184impl<S: Simd> core::ops::BitAnd for mask64x8<S> {
7185    type Output = Self;
7186    #[doc = "Compute the logical AND of two masks."]
7187    #[inline(always)]
7188    fn bitand(self, rhs: Self) -> Self::Output {
7189        self.simd.and_mask64x8(self, rhs)
7190    }
7191}
7192impl<S: Simd> core::ops::BitAndAssign for mask64x8<S> {
7193    #[doc = "Compute the logical AND of two masks."]
7194    #[inline(always)]
7195    fn bitand_assign(&mut self, rhs: Self) {
7196        *self = self.simd.and_mask64x8(*self, rhs);
7197    }
7198}
7199impl<S: Simd> core::ops::BitAnd<i64> for mask64x8<S> {
7200    type Output = Self;
7201    #[inline(always)]
7202    fn bitand(self, rhs: i64) -> Self::Output {
7203        self.simd.and_mask64x8(self, rhs.simd_into(self.simd))
7204    }
7205}
7206impl<S: Simd> core::ops::BitAndAssign<i64> for mask64x8<S> {
7207    #[inline(always)]
7208    fn bitand_assign(&mut self, rhs: i64) {
7209        *self = self.simd.and_mask64x8(*self, rhs.simd_into(self.simd));
7210    }
7211}
7212impl<S: Simd> core::ops::BitAnd<mask64x8<S>> for i64 {
7213    type Output = mask64x8<S>;
7214    #[inline(always)]
7215    fn bitand(self, rhs: mask64x8<S>) -> Self::Output {
7216        rhs.simd.and_mask64x8(self.simd_into(rhs.simd), rhs)
7217    }
7218}
7219impl<S: Simd> core::ops::BitOr for mask64x8<S> {
7220    type Output = Self;
7221    #[doc = "Compute the logical OR of two masks."]
7222    #[inline(always)]
7223    fn bitor(self, rhs: Self) -> Self::Output {
7224        self.simd.or_mask64x8(self, rhs)
7225    }
7226}
7227impl<S: Simd> core::ops::BitOrAssign for mask64x8<S> {
7228    #[doc = "Compute the logical OR of two masks."]
7229    #[inline(always)]
7230    fn bitor_assign(&mut self, rhs: Self) {
7231        *self = self.simd.or_mask64x8(*self, rhs);
7232    }
7233}
7234impl<S: Simd> core::ops::BitOr<i64> for mask64x8<S> {
7235    type Output = Self;
7236    #[inline(always)]
7237    fn bitor(self, rhs: i64) -> Self::Output {
7238        self.simd.or_mask64x8(self, rhs.simd_into(self.simd))
7239    }
7240}
7241impl<S: Simd> core::ops::BitOrAssign<i64> for mask64x8<S> {
7242    #[inline(always)]
7243    fn bitor_assign(&mut self, rhs: i64) {
7244        *self = self.simd.or_mask64x8(*self, rhs.simd_into(self.simd));
7245    }
7246}
7247impl<S: Simd> core::ops::BitOr<mask64x8<S>> for i64 {
7248    type Output = mask64x8<S>;
7249    #[inline(always)]
7250    fn bitor(self, rhs: mask64x8<S>) -> Self::Output {
7251        rhs.simd.or_mask64x8(self.simd_into(rhs.simd), rhs)
7252    }
7253}
7254impl<S: Simd> core::ops::BitXor for mask64x8<S> {
7255    type Output = Self;
7256    #[doc = "Compute the logical XOR of two masks."]
7257    #[inline(always)]
7258    fn bitxor(self, rhs: Self) -> Self::Output {
7259        self.simd.xor_mask64x8(self, rhs)
7260    }
7261}
7262impl<S: Simd> core::ops::BitXorAssign for mask64x8<S> {
7263    #[doc = "Compute the logical XOR of two masks."]
7264    #[inline(always)]
7265    fn bitxor_assign(&mut self, rhs: Self) {
7266        *self = self.simd.xor_mask64x8(*self, rhs);
7267    }
7268}
7269impl<S: Simd> core::ops::BitXor<i64> for mask64x8<S> {
7270    type Output = Self;
7271    #[inline(always)]
7272    fn bitxor(self, rhs: i64) -> Self::Output {
7273        self.simd.xor_mask64x8(self, rhs.simd_into(self.simd))
7274    }
7275}
7276impl<S: Simd> core::ops::BitXorAssign<i64> for mask64x8<S> {
7277    #[inline(always)]
7278    fn bitxor_assign(&mut self, rhs: i64) {
7279        *self = self.simd.xor_mask64x8(*self, rhs.simd_into(self.simd));
7280    }
7281}
7282impl<S: Simd> core::ops::BitXor<mask64x8<S>> for i64 {
7283    type Output = mask64x8<S>;
7284    #[inline(always)]
7285    fn bitxor(self, rhs: mask64x8<S>) -> Self::Output {
7286        rhs.simd.xor_mask64x8(self.simd_into(rhs.simd), rhs)
7287    }
7288}
7289impl<S: Simd> core::ops::Not for mask64x8<S> {
7290    type Output = Self;
7291    #[doc = "Compute the logical NOT of the mask."]
7292    #[inline(always)]
7293    fn not(self) -> Self::Output {
7294        self.simd.not_mask64x8(self)
7295    }
7296}