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    #[inline(always)]
16    fn neg(self) -> Self::Output {
17        self.simd.neg_f32x4(self)
18    }
19}
20impl<S: Simd> core::ops::Add for f32x4<S> {
21    type Output = Self;
22    #[inline(always)]
23    fn add(self, rhs: Self) -> Self::Output {
24        self.simd.add_f32x4(self, rhs)
25    }
26}
27impl<S: Simd> core::ops::Add<f32> for f32x4<S> {
28    type Output = Self;
29    #[inline(always)]
30    fn add(self, rhs: f32) -> Self::Output {
31        self.simd.add_f32x4(self, rhs.simd_into(self.simd))
32    }
33}
34impl<S: Simd> core::ops::Add<f32x4<S>> for f32 {
35    type Output = f32x4<S>;
36    #[inline(always)]
37    fn add(self, rhs: f32x4<S>) -> Self::Output {
38        rhs.simd.add_f32x4(self.simd_into(rhs.simd), rhs)
39    }
40}
41impl<S: Simd> core::ops::Sub for f32x4<S> {
42    type Output = Self;
43    #[inline(always)]
44    fn sub(self, rhs: Self) -> Self::Output {
45        self.simd.sub_f32x4(self, rhs)
46    }
47}
48impl<S: Simd> core::ops::Sub<f32> for f32x4<S> {
49    type Output = Self;
50    #[inline(always)]
51    fn sub(self, rhs: f32) -> Self::Output {
52        self.simd.sub_f32x4(self, rhs.simd_into(self.simd))
53    }
54}
55impl<S: Simd> core::ops::Sub<f32x4<S>> for f32 {
56    type Output = f32x4<S>;
57    #[inline(always)]
58    fn sub(self, rhs: f32x4<S>) -> Self::Output {
59        rhs.simd.sub_f32x4(self.simd_into(rhs.simd), rhs)
60    }
61}
62impl<S: Simd> core::ops::Mul for f32x4<S> {
63    type Output = Self;
64    #[inline(always)]
65    fn mul(self, rhs: Self) -> Self::Output {
66        self.simd.mul_f32x4(self, rhs)
67    }
68}
69impl<S: Simd> core::ops::Mul<f32> for f32x4<S> {
70    type Output = Self;
71    #[inline(always)]
72    fn mul(self, rhs: f32) -> Self::Output {
73        self.simd.mul_f32x4(self, rhs.simd_into(self.simd))
74    }
75}
76impl<S: Simd> core::ops::Mul<f32x4<S>> for f32 {
77    type Output = f32x4<S>;
78    #[inline(always)]
79    fn mul(self, rhs: f32x4<S>) -> Self::Output {
80        rhs.simd.mul_f32x4(self.simd_into(rhs.simd), rhs)
81    }
82}
83impl<S: Simd> core::ops::Div for f32x4<S> {
84    type Output = Self;
85    #[inline(always)]
86    fn div(self, rhs: Self) -> Self::Output {
87        self.simd.div_f32x4(self, rhs)
88    }
89}
90impl<S: Simd> core::ops::Div<f32> for f32x4<S> {
91    type Output = Self;
92    #[inline(always)]
93    fn div(self, rhs: f32) -> Self::Output {
94        self.simd.div_f32x4(self, rhs.simd_into(self.simd))
95    }
96}
97impl<S: Simd> core::ops::Div<f32x4<S>> for f32 {
98    type Output = f32x4<S>;
99    #[inline(always)]
100    fn div(self, rhs: f32x4<S>) -> Self::Output {
101        rhs.simd.div_f32x4(self.simd_into(rhs.simd), rhs)
102    }
103}
104impl<S: Simd> core::ops::Add for i8x16<S> {
105    type Output = Self;
106    #[inline(always)]
107    fn add(self, rhs: Self) -> Self::Output {
108        self.simd.add_i8x16(self, rhs)
109    }
110}
111impl<S: Simd> core::ops::Add<i8> for i8x16<S> {
112    type Output = Self;
113    #[inline(always)]
114    fn add(self, rhs: i8) -> Self::Output {
115        self.simd.add_i8x16(self, rhs.simd_into(self.simd))
116    }
117}
118impl<S: Simd> core::ops::Add<i8x16<S>> for i8 {
119    type Output = i8x16<S>;
120    #[inline(always)]
121    fn add(self, rhs: i8x16<S>) -> Self::Output {
122        rhs.simd.add_i8x16(self.simd_into(rhs.simd), rhs)
123    }
124}
125impl<S: Simd> core::ops::Sub for i8x16<S> {
126    type Output = Self;
127    #[inline(always)]
128    fn sub(self, rhs: Self) -> Self::Output {
129        self.simd.sub_i8x16(self, rhs)
130    }
131}
132impl<S: Simd> core::ops::Sub<i8> for i8x16<S> {
133    type Output = Self;
134    #[inline(always)]
135    fn sub(self, rhs: i8) -> Self::Output {
136        self.simd.sub_i8x16(self, rhs.simd_into(self.simd))
137    }
138}
139impl<S: Simd> core::ops::Sub<i8x16<S>> for i8 {
140    type Output = i8x16<S>;
141    #[inline(always)]
142    fn sub(self, rhs: i8x16<S>) -> Self::Output {
143        rhs.simd.sub_i8x16(self.simd_into(rhs.simd), rhs)
144    }
145}
146impl<S: Simd> core::ops::Mul for i8x16<S> {
147    type Output = Self;
148    #[inline(always)]
149    fn mul(self, rhs: Self) -> Self::Output {
150        self.simd.mul_i8x16(self, rhs)
151    }
152}
153impl<S: Simd> core::ops::Mul<i8> for i8x16<S> {
154    type Output = Self;
155    #[inline(always)]
156    fn mul(self, rhs: i8) -> Self::Output {
157        self.simd.mul_i8x16(self, rhs.simd_into(self.simd))
158    }
159}
160impl<S: Simd> core::ops::Mul<i8x16<S>> for i8 {
161    type Output = i8x16<S>;
162    #[inline(always)]
163    fn mul(self, rhs: i8x16<S>) -> Self::Output {
164        rhs.simd.mul_i8x16(self.simd_into(rhs.simd), rhs)
165    }
166}
167impl<S: Simd> core::ops::BitAnd for i8x16<S> {
168    type Output = Self;
169    #[inline(always)]
170    fn bitand(self, rhs: Self) -> Self::Output {
171        self.simd.and_i8x16(self, rhs)
172    }
173}
174impl<S: Simd> core::ops::BitAnd<i8> for i8x16<S> {
175    type Output = Self;
176    #[inline(always)]
177    fn bitand(self, rhs: i8) -> Self::Output {
178        self.simd.and_i8x16(self, rhs.simd_into(self.simd))
179    }
180}
181impl<S: Simd> core::ops::BitAnd<i8x16<S>> for i8 {
182    type Output = i8x16<S>;
183    #[inline(always)]
184    fn bitand(self, rhs: i8x16<S>) -> Self::Output {
185        rhs.simd.and_i8x16(self.simd_into(rhs.simd), rhs)
186    }
187}
188impl<S: Simd> core::ops::BitOr for i8x16<S> {
189    type Output = Self;
190    #[inline(always)]
191    fn bitor(self, rhs: Self) -> Self::Output {
192        self.simd.or_i8x16(self, rhs)
193    }
194}
195impl<S: Simd> core::ops::BitOr<i8> for i8x16<S> {
196    type Output = Self;
197    #[inline(always)]
198    fn bitor(self, rhs: i8) -> Self::Output {
199        self.simd.or_i8x16(self, rhs.simd_into(self.simd))
200    }
201}
202impl<S: Simd> core::ops::BitOr<i8x16<S>> for i8 {
203    type Output = i8x16<S>;
204    #[inline(always)]
205    fn bitor(self, rhs: i8x16<S>) -> Self::Output {
206        rhs.simd.or_i8x16(self.simd_into(rhs.simd), rhs)
207    }
208}
209impl<S: Simd> core::ops::BitXor for i8x16<S> {
210    type Output = Self;
211    #[inline(always)]
212    fn bitxor(self, rhs: Self) -> Self::Output {
213        self.simd.xor_i8x16(self, rhs)
214    }
215}
216impl<S: Simd> core::ops::BitXor<i8> for i8x16<S> {
217    type Output = Self;
218    #[inline(always)]
219    fn bitxor(self, rhs: i8) -> Self::Output {
220        self.simd.xor_i8x16(self, rhs.simd_into(self.simd))
221    }
222}
223impl<S: Simd> core::ops::BitXor<i8x16<S>> for i8 {
224    type Output = i8x16<S>;
225    #[inline(always)]
226    fn bitxor(self, rhs: i8x16<S>) -> Self::Output {
227        rhs.simd.xor_i8x16(self.simd_into(rhs.simd), rhs)
228    }
229}
230impl<S: Simd> core::ops::Add for u8x16<S> {
231    type Output = Self;
232    #[inline(always)]
233    fn add(self, rhs: Self) -> Self::Output {
234        self.simd.add_u8x16(self, rhs)
235    }
236}
237impl<S: Simd> core::ops::Add<u8> for u8x16<S> {
238    type Output = Self;
239    #[inline(always)]
240    fn add(self, rhs: u8) -> Self::Output {
241        self.simd.add_u8x16(self, rhs.simd_into(self.simd))
242    }
243}
244impl<S: Simd> core::ops::Add<u8x16<S>> for u8 {
245    type Output = u8x16<S>;
246    #[inline(always)]
247    fn add(self, rhs: u8x16<S>) -> Self::Output {
248        rhs.simd.add_u8x16(self.simd_into(rhs.simd), rhs)
249    }
250}
251impl<S: Simd> core::ops::Sub for u8x16<S> {
252    type Output = Self;
253    #[inline(always)]
254    fn sub(self, rhs: Self) -> Self::Output {
255        self.simd.sub_u8x16(self, rhs)
256    }
257}
258impl<S: Simd> core::ops::Sub<u8> for u8x16<S> {
259    type Output = Self;
260    #[inline(always)]
261    fn sub(self, rhs: u8) -> Self::Output {
262        self.simd.sub_u8x16(self, rhs.simd_into(self.simd))
263    }
264}
265impl<S: Simd> core::ops::Sub<u8x16<S>> for u8 {
266    type Output = u8x16<S>;
267    #[inline(always)]
268    fn sub(self, rhs: u8x16<S>) -> Self::Output {
269        rhs.simd.sub_u8x16(self.simd_into(rhs.simd), rhs)
270    }
271}
272impl<S: Simd> core::ops::Mul for u8x16<S> {
273    type Output = Self;
274    #[inline(always)]
275    fn mul(self, rhs: Self) -> Self::Output {
276        self.simd.mul_u8x16(self, rhs)
277    }
278}
279impl<S: Simd> core::ops::Mul<u8> for u8x16<S> {
280    type Output = Self;
281    #[inline(always)]
282    fn mul(self, rhs: u8) -> Self::Output {
283        self.simd.mul_u8x16(self, rhs.simd_into(self.simd))
284    }
285}
286impl<S: Simd> core::ops::Mul<u8x16<S>> for u8 {
287    type Output = u8x16<S>;
288    #[inline(always)]
289    fn mul(self, rhs: u8x16<S>) -> Self::Output {
290        rhs.simd.mul_u8x16(self.simd_into(rhs.simd), rhs)
291    }
292}
293impl<S: Simd> core::ops::BitAnd for u8x16<S> {
294    type Output = Self;
295    #[inline(always)]
296    fn bitand(self, rhs: Self) -> Self::Output {
297        self.simd.and_u8x16(self, rhs)
298    }
299}
300impl<S: Simd> core::ops::BitAnd<u8> for u8x16<S> {
301    type Output = Self;
302    #[inline(always)]
303    fn bitand(self, rhs: u8) -> Self::Output {
304        self.simd.and_u8x16(self, rhs.simd_into(self.simd))
305    }
306}
307impl<S: Simd> core::ops::BitAnd<u8x16<S>> for u8 {
308    type Output = u8x16<S>;
309    #[inline(always)]
310    fn bitand(self, rhs: u8x16<S>) -> Self::Output {
311        rhs.simd.and_u8x16(self.simd_into(rhs.simd), rhs)
312    }
313}
314impl<S: Simd> core::ops::BitOr for u8x16<S> {
315    type Output = Self;
316    #[inline(always)]
317    fn bitor(self, rhs: Self) -> Self::Output {
318        self.simd.or_u8x16(self, rhs)
319    }
320}
321impl<S: Simd> core::ops::BitOr<u8> for u8x16<S> {
322    type Output = Self;
323    #[inline(always)]
324    fn bitor(self, rhs: u8) -> Self::Output {
325        self.simd.or_u8x16(self, rhs.simd_into(self.simd))
326    }
327}
328impl<S: Simd> core::ops::BitOr<u8x16<S>> for u8 {
329    type Output = u8x16<S>;
330    #[inline(always)]
331    fn bitor(self, rhs: u8x16<S>) -> Self::Output {
332        rhs.simd.or_u8x16(self.simd_into(rhs.simd), rhs)
333    }
334}
335impl<S: Simd> core::ops::BitXor for u8x16<S> {
336    type Output = Self;
337    #[inline(always)]
338    fn bitxor(self, rhs: Self) -> Self::Output {
339        self.simd.xor_u8x16(self, rhs)
340    }
341}
342impl<S: Simd> core::ops::BitXor<u8> for u8x16<S> {
343    type Output = Self;
344    #[inline(always)]
345    fn bitxor(self, rhs: u8) -> Self::Output {
346        self.simd.xor_u8x16(self, rhs.simd_into(self.simd))
347    }
348}
349impl<S: Simd> core::ops::BitXor<u8x16<S>> for u8 {
350    type Output = u8x16<S>;
351    #[inline(always)]
352    fn bitxor(self, rhs: u8x16<S>) -> Self::Output {
353        rhs.simd.xor_u8x16(self.simd_into(rhs.simd), rhs)
354    }
355}
356impl<S: Simd> core::ops::BitAnd for mask8x16<S> {
357    type Output = Self;
358    #[inline(always)]
359    fn bitand(self, rhs: Self) -> Self::Output {
360        self.simd.and_mask8x16(self, rhs)
361    }
362}
363impl<S: Simd> core::ops::BitAnd<i8> for mask8x16<S> {
364    type Output = Self;
365    #[inline(always)]
366    fn bitand(self, rhs: i8) -> Self::Output {
367        self.simd.and_mask8x16(self, rhs.simd_into(self.simd))
368    }
369}
370impl<S: Simd> core::ops::BitAnd<mask8x16<S>> for i8 {
371    type Output = mask8x16<S>;
372    #[inline(always)]
373    fn bitand(self, rhs: mask8x16<S>) -> Self::Output {
374        rhs.simd.and_mask8x16(self.simd_into(rhs.simd), rhs)
375    }
376}
377impl<S: Simd> core::ops::BitOr for mask8x16<S> {
378    type Output = Self;
379    #[inline(always)]
380    fn bitor(self, rhs: Self) -> Self::Output {
381        self.simd.or_mask8x16(self, rhs)
382    }
383}
384impl<S: Simd> core::ops::BitOr<i8> for mask8x16<S> {
385    type Output = Self;
386    #[inline(always)]
387    fn bitor(self, rhs: i8) -> Self::Output {
388        self.simd.or_mask8x16(self, rhs.simd_into(self.simd))
389    }
390}
391impl<S: Simd> core::ops::BitOr<mask8x16<S>> for i8 {
392    type Output = mask8x16<S>;
393    #[inline(always)]
394    fn bitor(self, rhs: mask8x16<S>) -> Self::Output {
395        rhs.simd.or_mask8x16(self.simd_into(rhs.simd), rhs)
396    }
397}
398impl<S: Simd> core::ops::BitXor for mask8x16<S> {
399    type Output = Self;
400    #[inline(always)]
401    fn bitxor(self, rhs: Self) -> Self::Output {
402        self.simd.xor_mask8x16(self, rhs)
403    }
404}
405impl<S: Simd> core::ops::BitXor<i8> for mask8x16<S> {
406    type Output = Self;
407    #[inline(always)]
408    fn bitxor(self, rhs: i8) -> Self::Output {
409        self.simd.xor_mask8x16(self, rhs.simd_into(self.simd))
410    }
411}
412impl<S: Simd> core::ops::BitXor<mask8x16<S>> for i8 {
413    type Output = mask8x16<S>;
414    #[inline(always)]
415    fn bitxor(self, rhs: mask8x16<S>) -> Self::Output {
416        rhs.simd.xor_mask8x16(self.simd_into(rhs.simd), rhs)
417    }
418}
419impl<S: Simd> core::ops::Not for mask8x16<S> {
420    type Output = Self;
421    #[inline(always)]
422    fn not(self) -> Self::Output {
423        self.simd.not_mask8x16(self)
424    }
425}
426impl<S: Simd> core::ops::Add for i16x8<S> {
427    type Output = Self;
428    #[inline(always)]
429    fn add(self, rhs: Self) -> Self::Output {
430        self.simd.add_i16x8(self, rhs)
431    }
432}
433impl<S: Simd> core::ops::Add<i16> for i16x8<S> {
434    type Output = Self;
435    #[inline(always)]
436    fn add(self, rhs: i16) -> Self::Output {
437        self.simd.add_i16x8(self, rhs.simd_into(self.simd))
438    }
439}
440impl<S: Simd> core::ops::Add<i16x8<S>> for i16 {
441    type Output = i16x8<S>;
442    #[inline(always)]
443    fn add(self, rhs: i16x8<S>) -> Self::Output {
444        rhs.simd.add_i16x8(self.simd_into(rhs.simd), rhs)
445    }
446}
447impl<S: Simd> core::ops::Sub for i16x8<S> {
448    type Output = Self;
449    #[inline(always)]
450    fn sub(self, rhs: Self) -> Self::Output {
451        self.simd.sub_i16x8(self, rhs)
452    }
453}
454impl<S: Simd> core::ops::Sub<i16> for i16x8<S> {
455    type Output = Self;
456    #[inline(always)]
457    fn sub(self, rhs: i16) -> Self::Output {
458        self.simd.sub_i16x8(self, rhs.simd_into(self.simd))
459    }
460}
461impl<S: Simd> core::ops::Sub<i16x8<S>> for i16 {
462    type Output = i16x8<S>;
463    #[inline(always)]
464    fn sub(self, rhs: i16x8<S>) -> Self::Output {
465        rhs.simd.sub_i16x8(self.simd_into(rhs.simd), rhs)
466    }
467}
468impl<S: Simd> core::ops::Mul for i16x8<S> {
469    type Output = Self;
470    #[inline(always)]
471    fn mul(self, rhs: Self) -> Self::Output {
472        self.simd.mul_i16x8(self, rhs)
473    }
474}
475impl<S: Simd> core::ops::Mul<i16> for i16x8<S> {
476    type Output = Self;
477    #[inline(always)]
478    fn mul(self, rhs: i16) -> Self::Output {
479        self.simd.mul_i16x8(self, rhs.simd_into(self.simd))
480    }
481}
482impl<S: Simd> core::ops::Mul<i16x8<S>> for i16 {
483    type Output = i16x8<S>;
484    #[inline(always)]
485    fn mul(self, rhs: i16x8<S>) -> Self::Output {
486        rhs.simd.mul_i16x8(self.simd_into(rhs.simd), rhs)
487    }
488}
489impl<S: Simd> core::ops::BitAnd for i16x8<S> {
490    type Output = Self;
491    #[inline(always)]
492    fn bitand(self, rhs: Self) -> Self::Output {
493        self.simd.and_i16x8(self, rhs)
494    }
495}
496impl<S: Simd> core::ops::BitAnd<i16> for i16x8<S> {
497    type Output = Self;
498    #[inline(always)]
499    fn bitand(self, rhs: i16) -> Self::Output {
500        self.simd.and_i16x8(self, rhs.simd_into(self.simd))
501    }
502}
503impl<S: Simd> core::ops::BitAnd<i16x8<S>> for i16 {
504    type Output = i16x8<S>;
505    #[inline(always)]
506    fn bitand(self, rhs: i16x8<S>) -> Self::Output {
507        rhs.simd.and_i16x8(self.simd_into(rhs.simd), rhs)
508    }
509}
510impl<S: Simd> core::ops::BitOr for i16x8<S> {
511    type Output = Self;
512    #[inline(always)]
513    fn bitor(self, rhs: Self) -> Self::Output {
514        self.simd.or_i16x8(self, rhs)
515    }
516}
517impl<S: Simd> core::ops::BitOr<i16> for i16x8<S> {
518    type Output = Self;
519    #[inline(always)]
520    fn bitor(self, rhs: i16) -> Self::Output {
521        self.simd.or_i16x8(self, rhs.simd_into(self.simd))
522    }
523}
524impl<S: Simd> core::ops::BitOr<i16x8<S>> for i16 {
525    type Output = i16x8<S>;
526    #[inline(always)]
527    fn bitor(self, rhs: i16x8<S>) -> Self::Output {
528        rhs.simd.or_i16x8(self.simd_into(rhs.simd), rhs)
529    }
530}
531impl<S: Simd> core::ops::BitXor for i16x8<S> {
532    type Output = Self;
533    #[inline(always)]
534    fn bitxor(self, rhs: Self) -> Self::Output {
535        self.simd.xor_i16x8(self, rhs)
536    }
537}
538impl<S: Simd> core::ops::BitXor<i16> for i16x8<S> {
539    type Output = Self;
540    #[inline(always)]
541    fn bitxor(self, rhs: i16) -> Self::Output {
542        self.simd.xor_i16x8(self, rhs.simd_into(self.simd))
543    }
544}
545impl<S: Simd> core::ops::BitXor<i16x8<S>> for i16 {
546    type Output = i16x8<S>;
547    #[inline(always)]
548    fn bitxor(self, rhs: i16x8<S>) -> Self::Output {
549        rhs.simd.xor_i16x8(self.simd_into(rhs.simd), rhs)
550    }
551}
552impl<S: Simd> core::ops::Add for u16x8<S> {
553    type Output = Self;
554    #[inline(always)]
555    fn add(self, rhs: Self) -> Self::Output {
556        self.simd.add_u16x8(self, rhs)
557    }
558}
559impl<S: Simd> core::ops::Add<u16> for u16x8<S> {
560    type Output = Self;
561    #[inline(always)]
562    fn add(self, rhs: u16) -> Self::Output {
563        self.simd.add_u16x8(self, rhs.simd_into(self.simd))
564    }
565}
566impl<S: Simd> core::ops::Add<u16x8<S>> for u16 {
567    type Output = u16x8<S>;
568    #[inline(always)]
569    fn add(self, rhs: u16x8<S>) -> Self::Output {
570        rhs.simd.add_u16x8(self.simd_into(rhs.simd), rhs)
571    }
572}
573impl<S: Simd> core::ops::Sub for u16x8<S> {
574    type Output = Self;
575    #[inline(always)]
576    fn sub(self, rhs: Self) -> Self::Output {
577        self.simd.sub_u16x8(self, rhs)
578    }
579}
580impl<S: Simd> core::ops::Sub<u16> for u16x8<S> {
581    type Output = Self;
582    #[inline(always)]
583    fn sub(self, rhs: u16) -> Self::Output {
584        self.simd.sub_u16x8(self, rhs.simd_into(self.simd))
585    }
586}
587impl<S: Simd> core::ops::Sub<u16x8<S>> for u16 {
588    type Output = u16x8<S>;
589    #[inline(always)]
590    fn sub(self, rhs: u16x8<S>) -> Self::Output {
591        rhs.simd.sub_u16x8(self.simd_into(rhs.simd), rhs)
592    }
593}
594impl<S: Simd> core::ops::Mul for u16x8<S> {
595    type Output = Self;
596    #[inline(always)]
597    fn mul(self, rhs: Self) -> Self::Output {
598        self.simd.mul_u16x8(self, rhs)
599    }
600}
601impl<S: Simd> core::ops::Mul<u16> for u16x8<S> {
602    type Output = Self;
603    #[inline(always)]
604    fn mul(self, rhs: u16) -> Self::Output {
605        self.simd.mul_u16x8(self, rhs.simd_into(self.simd))
606    }
607}
608impl<S: Simd> core::ops::Mul<u16x8<S>> for u16 {
609    type Output = u16x8<S>;
610    #[inline(always)]
611    fn mul(self, rhs: u16x8<S>) -> Self::Output {
612        rhs.simd.mul_u16x8(self.simd_into(rhs.simd), rhs)
613    }
614}
615impl<S: Simd> core::ops::BitAnd for u16x8<S> {
616    type Output = Self;
617    #[inline(always)]
618    fn bitand(self, rhs: Self) -> Self::Output {
619        self.simd.and_u16x8(self, rhs)
620    }
621}
622impl<S: Simd> core::ops::BitAnd<u16> for u16x8<S> {
623    type Output = Self;
624    #[inline(always)]
625    fn bitand(self, rhs: u16) -> Self::Output {
626        self.simd.and_u16x8(self, rhs.simd_into(self.simd))
627    }
628}
629impl<S: Simd> core::ops::BitAnd<u16x8<S>> for u16 {
630    type Output = u16x8<S>;
631    #[inline(always)]
632    fn bitand(self, rhs: u16x8<S>) -> Self::Output {
633        rhs.simd.and_u16x8(self.simd_into(rhs.simd), rhs)
634    }
635}
636impl<S: Simd> core::ops::BitOr for u16x8<S> {
637    type Output = Self;
638    #[inline(always)]
639    fn bitor(self, rhs: Self) -> Self::Output {
640        self.simd.or_u16x8(self, rhs)
641    }
642}
643impl<S: Simd> core::ops::BitOr<u16> for u16x8<S> {
644    type Output = Self;
645    #[inline(always)]
646    fn bitor(self, rhs: u16) -> Self::Output {
647        self.simd.or_u16x8(self, rhs.simd_into(self.simd))
648    }
649}
650impl<S: Simd> core::ops::BitOr<u16x8<S>> for u16 {
651    type Output = u16x8<S>;
652    #[inline(always)]
653    fn bitor(self, rhs: u16x8<S>) -> Self::Output {
654        rhs.simd.or_u16x8(self.simd_into(rhs.simd), rhs)
655    }
656}
657impl<S: Simd> core::ops::BitXor for u16x8<S> {
658    type Output = Self;
659    #[inline(always)]
660    fn bitxor(self, rhs: Self) -> Self::Output {
661        self.simd.xor_u16x8(self, rhs)
662    }
663}
664impl<S: Simd> core::ops::BitXor<u16> for u16x8<S> {
665    type Output = Self;
666    #[inline(always)]
667    fn bitxor(self, rhs: u16) -> Self::Output {
668        self.simd.xor_u16x8(self, rhs.simd_into(self.simd))
669    }
670}
671impl<S: Simd> core::ops::BitXor<u16x8<S>> for u16 {
672    type Output = u16x8<S>;
673    #[inline(always)]
674    fn bitxor(self, rhs: u16x8<S>) -> Self::Output {
675        rhs.simd.xor_u16x8(self.simd_into(rhs.simd), rhs)
676    }
677}
678impl<S: Simd> core::ops::BitAnd for mask16x8<S> {
679    type Output = Self;
680    #[inline(always)]
681    fn bitand(self, rhs: Self) -> Self::Output {
682        self.simd.and_mask16x8(self, rhs)
683    }
684}
685impl<S: Simd> core::ops::BitAnd<i16> for mask16x8<S> {
686    type Output = Self;
687    #[inline(always)]
688    fn bitand(self, rhs: i16) -> Self::Output {
689        self.simd.and_mask16x8(self, rhs.simd_into(self.simd))
690    }
691}
692impl<S: Simd> core::ops::BitAnd<mask16x8<S>> for i16 {
693    type Output = mask16x8<S>;
694    #[inline(always)]
695    fn bitand(self, rhs: mask16x8<S>) -> Self::Output {
696        rhs.simd.and_mask16x8(self.simd_into(rhs.simd), rhs)
697    }
698}
699impl<S: Simd> core::ops::BitOr for mask16x8<S> {
700    type Output = Self;
701    #[inline(always)]
702    fn bitor(self, rhs: Self) -> Self::Output {
703        self.simd.or_mask16x8(self, rhs)
704    }
705}
706impl<S: Simd> core::ops::BitOr<i16> for mask16x8<S> {
707    type Output = Self;
708    #[inline(always)]
709    fn bitor(self, rhs: i16) -> Self::Output {
710        self.simd.or_mask16x8(self, rhs.simd_into(self.simd))
711    }
712}
713impl<S: Simd> core::ops::BitOr<mask16x8<S>> for i16 {
714    type Output = mask16x8<S>;
715    #[inline(always)]
716    fn bitor(self, rhs: mask16x8<S>) -> Self::Output {
717        rhs.simd.or_mask16x8(self.simd_into(rhs.simd), rhs)
718    }
719}
720impl<S: Simd> core::ops::BitXor for mask16x8<S> {
721    type Output = Self;
722    #[inline(always)]
723    fn bitxor(self, rhs: Self) -> Self::Output {
724        self.simd.xor_mask16x8(self, rhs)
725    }
726}
727impl<S: Simd> core::ops::BitXor<i16> for mask16x8<S> {
728    type Output = Self;
729    #[inline(always)]
730    fn bitxor(self, rhs: i16) -> Self::Output {
731        self.simd.xor_mask16x8(self, rhs.simd_into(self.simd))
732    }
733}
734impl<S: Simd> core::ops::BitXor<mask16x8<S>> for i16 {
735    type Output = mask16x8<S>;
736    #[inline(always)]
737    fn bitxor(self, rhs: mask16x8<S>) -> Self::Output {
738        rhs.simd.xor_mask16x8(self.simd_into(rhs.simd), rhs)
739    }
740}
741impl<S: Simd> core::ops::Not for mask16x8<S> {
742    type Output = Self;
743    #[inline(always)]
744    fn not(self) -> Self::Output {
745        self.simd.not_mask16x8(self)
746    }
747}
748impl<S: Simd> core::ops::Add for i32x4<S> {
749    type Output = Self;
750    #[inline(always)]
751    fn add(self, rhs: Self) -> Self::Output {
752        self.simd.add_i32x4(self, rhs)
753    }
754}
755impl<S: Simd> core::ops::Add<i32> for i32x4<S> {
756    type Output = Self;
757    #[inline(always)]
758    fn add(self, rhs: i32) -> Self::Output {
759        self.simd.add_i32x4(self, rhs.simd_into(self.simd))
760    }
761}
762impl<S: Simd> core::ops::Add<i32x4<S>> for i32 {
763    type Output = i32x4<S>;
764    #[inline(always)]
765    fn add(self, rhs: i32x4<S>) -> Self::Output {
766        rhs.simd.add_i32x4(self.simd_into(rhs.simd), rhs)
767    }
768}
769impl<S: Simd> core::ops::Sub for i32x4<S> {
770    type Output = Self;
771    #[inline(always)]
772    fn sub(self, rhs: Self) -> Self::Output {
773        self.simd.sub_i32x4(self, rhs)
774    }
775}
776impl<S: Simd> core::ops::Sub<i32> for i32x4<S> {
777    type Output = Self;
778    #[inline(always)]
779    fn sub(self, rhs: i32) -> Self::Output {
780        self.simd.sub_i32x4(self, rhs.simd_into(self.simd))
781    }
782}
783impl<S: Simd> core::ops::Sub<i32x4<S>> for i32 {
784    type Output = i32x4<S>;
785    #[inline(always)]
786    fn sub(self, rhs: i32x4<S>) -> Self::Output {
787        rhs.simd.sub_i32x4(self.simd_into(rhs.simd), rhs)
788    }
789}
790impl<S: Simd> core::ops::Mul for i32x4<S> {
791    type Output = Self;
792    #[inline(always)]
793    fn mul(self, rhs: Self) -> Self::Output {
794        self.simd.mul_i32x4(self, rhs)
795    }
796}
797impl<S: Simd> core::ops::Mul<i32> for i32x4<S> {
798    type Output = Self;
799    #[inline(always)]
800    fn mul(self, rhs: i32) -> Self::Output {
801        self.simd.mul_i32x4(self, rhs.simd_into(self.simd))
802    }
803}
804impl<S: Simd> core::ops::Mul<i32x4<S>> for i32 {
805    type Output = i32x4<S>;
806    #[inline(always)]
807    fn mul(self, rhs: i32x4<S>) -> Self::Output {
808        rhs.simd.mul_i32x4(self.simd_into(rhs.simd), rhs)
809    }
810}
811impl<S: Simd> core::ops::BitAnd for i32x4<S> {
812    type Output = Self;
813    #[inline(always)]
814    fn bitand(self, rhs: Self) -> Self::Output {
815        self.simd.and_i32x4(self, rhs)
816    }
817}
818impl<S: Simd> core::ops::BitAnd<i32> for i32x4<S> {
819    type Output = Self;
820    #[inline(always)]
821    fn bitand(self, rhs: i32) -> Self::Output {
822        self.simd.and_i32x4(self, rhs.simd_into(self.simd))
823    }
824}
825impl<S: Simd> core::ops::BitAnd<i32x4<S>> for i32 {
826    type Output = i32x4<S>;
827    #[inline(always)]
828    fn bitand(self, rhs: i32x4<S>) -> Self::Output {
829        rhs.simd.and_i32x4(self.simd_into(rhs.simd), rhs)
830    }
831}
832impl<S: Simd> core::ops::BitOr for i32x4<S> {
833    type Output = Self;
834    #[inline(always)]
835    fn bitor(self, rhs: Self) -> Self::Output {
836        self.simd.or_i32x4(self, rhs)
837    }
838}
839impl<S: Simd> core::ops::BitOr<i32> for i32x4<S> {
840    type Output = Self;
841    #[inline(always)]
842    fn bitor(self, rhs: i32) -> Self::Output {
843        self.simd.or_i32x4(self, rhs.simd_into(self.simd))
844    }
845}
846impl<S: Simd> core::ops::BitOr<i32x4<S>> for i32 {
847    type Output = i32x4<S>;
848    #[inline(always)]
849    fn bitor(self, rhs: i32x4<S>) -> Self::Output {
850        rhs.simd.or_i32x4(self.simd_into(rhs.simd), rhs)
851    }
852}
853impl<S: Simd> core::ops::BitXor for i32x4<S> {
854    type Output = Self;
855    #[inline(always)]
856    fn bitxor(self, rhs: Self) -> Self::Output {
857        self.simd.xor_i32x4(self, rhs)
858    }
859}
860impl<S: Simd> core::ops::BitXor<i32> for i32x4<S> {
861    type Output = Self;
862    #[inline(always)]
863    fn bitxor(self, rhs: i32) -> Self::Output {
864        self.simd.xor_i32x4(self, rhs.simd_into(self.simd))
865    }
866}
867impl<S: Simd> core::ops::BitXor<i32x4<S>> for i32 {
868    type Output = i32x4<S>;
869    #[inline(always)]
870    fn bitxor(self, rhs: i32x4<S>) -> Self::Output {
871        rhs.simd.xor_i32x4(self.simd_into(rhs.simd), rhs)
872    }
873}
874impl<S: Simd> core::ops::Add for u32x4<S> {
875    type Output = Self;
876    #[inline(always)]
877    fn add(self, rhs: Self) -> Self::Output {
878        self.simd.add_u32x4(self, rhs)
879    }
880}
881impl<S: Simd> core::ops::Add<u32> for u32x4<S> {
882    type Output = Self;
883    #[inline(always)]
884    fn add(self, rhs: u32) -> Self::Output {
885        self.simd.add_u32x4(self, rhs.simd_into(self.simd))
886    }
887}
888impl<S: Simd> core::ops::Add<u32x4<S>> for u32 {
889    type Output = u32x4<S>;
890    #[inline(always)]
891    fn add(self, rhs: u32x4<S>) -> Self::Output {
892        rhs.simd.add_u32x4(self.simd_into(rhs.simd), rhs)
893    }
894}
895impl<S: Simd> core::ops::Sub for u32x4<S> {
896    type Output = Self;
897    #[inline(always)]
898    fn sub(self, rhs: Self) -> Self::Output {
899        self.simd.sub_u32x4(self, rhs)
900    }
901}
902impl<S: Simd> core::ops::Sub<u32> for u32x4<S> {
903    type Output = Self;
904    #[inline(always)]
905    fn sub(self, rhs: u32) -> Self::Output {
906        self.simd.sub_u32x4(self, rhs.simd_into(self.simd))
907    }
908}
909impl<S: Simd> core::ops::Sub<u32x4<S>> for u32 {
910    type Output = u32x4<S>;
911    #[inline(always)]
912    fn sub(self, rhs: u32x4<S>) -> Self::Output {
913        rhs.simd.sub_u32x4(self.simd_into(rhs.simd), rhs)
914    }
915}
916impl<S: Simd> core::ops::Mul for u32x4<S> {
917    type Output = Self;
918    #[inline(always)]
919    fn mul(self, rhs: Self) -> Self::Output {
920        self.simd.mul_u32x4(self, rhs)
921    }
922}
923impl<S: Simd> core::ops::Mul<u32> for u32x4<S> {
924    type Output = Self;
925    #[inline(always)]
926    fn mul(self, rhs: u32) -> Self::Output {
927        self.simd.mul_u32x4(self, rhs.simd_into(self.simd))
928    }
929}
930impl<S: Simd> core::ops::Mul<u32x4<S>> for u32 {
931    type Output = u32x4<S>;
932    #[inline(always)]
933    fn mul(self, rhs: u32x4<S>) -> Self::Output {
934        rhs.simd.mul_u32x4(self.simd_into(rhs.simd), rhs)
935    }
936}
937impl<S: Simd> core::ops::BitAnd for u32x4<S> {
938    type Output = Self;
939    #[inline(always)]
940    fn bitand(self, rhs: Self) -> Self::Output {
941        self.simd.and_u32x4(self, rhs)
942    }
943}
944impl<S: Simd> core::ops::BitAnd<u32> for u32x4<S> {
945    type Output = Self;
946    #[inline(always)]
947    fn bitand(self, rhs: u32) -> Self::Output {
948        self.simd.and_u32x4(self, rhs.simd_into(self.simd))
949    }
950}
951impl<S: Simd> core::ops::BitAnd<u32x4<S>> for u32 {
952    type Output = u32x4<S>;
953    #[inline(always)]
954    fn bitand(self, rhs: u32x4<S>) -> Self::Output {
955        rhs.simd.and_u32x4(self.simd_into(rhs.simd), rhs)
956    }
957}
958impl<S: Simd> core::ops::BitOr for u32x4<S> {
959    type Output = Self;
960    #[inline(always)]
961    fn bitor(self, rhs: Self) -> Self::Output {
962        self.simd.or_u32x4(self, rhs)
963    }
964}
965impl<S: Simd> core::ops::BitOr<u32> for u32x4<S> {
966    type Output = Self;
967    #[inline(always)]
968    fn bitor(self, rhs: u32) -> Self::Output {
969        self.simd.or_u32x4(self, rhs.simd_into(self.simd))
970    }
971}
972impl<S: Simd> core::ops::BitOr<u32x4<S>> for u32 {
973    type Output = u32x4<S>;
974    #[inline(always)]
975    fn bitor(self, rhs: u32x4<S>) -> Self::Output {
976        rhs.simd.or_u32x4(self.simd_into(rhs.simd), rhs)
977    }
978}
979impl<S: Simd> core::ops::BitXor for u32x4<S> {
980    type Output = Self;
981    #[inline(always)]
982    fn bitxor(self, rhs: Self) -> Self::Output {
983        self.simd.xor_u32x4(self, rhs)
984    }
985}
986impl<S: Simd> core::ops::BitXor<u32> for u32x4<S> {
987    type Output = Self;
988    #[inline(always)]
989    fn bitxor(self, rhs: u32) -> Self::Output {
990        self.simd.xor_u32x4(self, rhs.simd_into(self.simd))
991    }
992}
993impl<S: Simd> core::ops::BitXor<u32x4<S>> for u32 {
994    type Output = u32x4<S>;
995    #[inline(always)]
996    fn bitxor(self, rhs: u32x4<S>) -> Self::Output {
997        rhs.simd.xor_u32x4(self.simd_into(rhs.simd), rhs)
998    }
999}
1000impl<S: Simd> core::ops::BitAnd for mask32x4<S> {
1001    type Output = Self;
1002    #[inline(always)]
1003    fn bitand(self, rhs: Self) -> Self::Output {
1004        self.simd.and_mask32x4(self, rhs)
1005    }
1006}
1007impl<S: Simd> core::ops::BitAnd<i32> for mask32x4<S> {
1008    type Output = Self;
1009    #[inline(always)]
1010    fn bitand(self, rhs: i32) -> Self::Output {
1011        self.simd.and_mask32x4(self, rhs.simd_into(self.simd))
1012    }
1013}
1014impl<S: Simd> core::ops::BitAnd<mask32x4<S>> for i32 {
1015    type Output = mask32x4<S>;
1016    #[inline(always)]
1017    fn bitand(self, rhs: mask32x4<S>) -> Self::Output {
1018        rhs.simd.and_mask32x4(self.simd_into(rhs.simd), rhs)
1019    }
1020}
1021impl<S: Simd> core::ops::BitOr for mask32x4<S> {
1022    type Output = Self;
1023    #[inline(always)]
1024    fn bitor(self, rhs: Self) -> Self::Output {
1025        self.simd.or_mask32x4(self, rhs)
1026    }
1027}
1028impl<S: Simd> core::ops::BitOr<i32> for mask32x4<S> {
1029    type Output = Self;
1030    #[inline(always)]
1031    fn bitor(self, rhs: i32) -> Self::Output {
1032        self.simd.or_mask32x4(self, rhs.simd_into(self.simd))
1033    }
1034}
1035impl<S: Simd> core::ops::BitOr<mask32x4<S>> for i32 {
1036    type Output = mask32x4<S>;
1037    #[inline(always)]
1038    fn bitor(self, rhs: mask32x4<S>) -> Self::Output {
1039        rhs.simd.or_mask32x4(self.simd_into(rhs.simd), rhs)
1040    }
1041}
1042impl<S: Simd> core::ops::BitXor for mask32x4<S> {
1043    type Output = Self;
1044    #[inline(always)]
1045    fn bitxor(self, rhs: Self) -> Self::Output {
1046        self.simd.xor_mask32x4(self, rhs)
1047    }
1048}
1049impl<S: Simd> core::ops::BitXor<i32> for mask32x4<S> {
1050    type Output = Self;
1051    #[inline(always)]
1052    fn bitxor(self, rhs: i32) -> Self::Output {
1053        self.simd.xor_mask32x4(self, rhs.simd_into(self.simd))
1054    }
1055}
1056impl<S: Simd> core::ops::BitXor<mask32x4<S>> for i32 {
1057    type Output = mask32x4<S>;
1058    #[inline(always)]
1059    fn bitxor(self, rhs: mask32x4<S>) -> Self::Output {
1060        rhs.simd.xor_mask32x4(self.simd_into(rhs.simd), rhs)
1061    }
1062}
1063impl<S: Simd> core::ops::Not for mask32x4<S> {
1064    type Output = Self;
1065    #[inline(always)]
1066    fn not(self) -> Self::Output {
1067        self.simd.not_mask32x4(self)
1068    }
1069}
1070impl<S: Simd> core::ops::Neg for f64x2<S> {
1071    type Output = Self;
1072    #[inline(always)]
1073    fn neg(self) -> Self::Output {
1074        self.simd.neg_f64x2(self)
1075    }
1076}
1077impl<S: Simd> core::ops::Add for f64x2<S> {
1078    type Output = Self;
1079    #[inline(always)]
1080    fn add(self, rhs: Self) -> Self::Output {
1081        self.simd.add_f64x2(self, rhs)
1082    }
1083}
1084impl<S: Simd> core::ops::Add<f64> for f64x2<S> {
1085    type Output = Self;
1086    #[inline(always)]
1087    fn add(self, rhs: f64) -> Self::Output {
1088        self.simd.add_f64x2(self, rhs.simd_into(self.simd))
1089    }
1090}
1091impl<S: Simd> core::ops::Add<f64x2<S>> for f64 {
1092    type Output = f64x2<S>;
1093    #[inline(always)]
1094    fn add(self, rhs: f64x2<S>) -> Self::Output {
1095        rhs.simd.add_f64x2(self.simd_into(rhs.simd), rhs)
1096    }
1097}
1098impl<S: Simd> core::ops::Sub for f64x2<S> {
1099    type Output = Self;
1100    #[inline(always)]
1101    fn sub(self, rhs: Self) -> Self::Output {
1102        self.simd.sub_f64x2(self, rhs)
1103    }
1104}
1105impl<S: Simd> core::ops::Sub<f64> for f64x2<S> {
1106    type Output = Self;
1107    #[inline(always)]
1108    fn sub(self, rhs: f64) -> Self::Output {
1109        self.simd.sub_f64x2(self, rhs.simd_into(self.simd))
1110    }
1111}
1112impl<S: Simd> core::ops::Sub<f64x2<S>> for f64 {
1113    type Output = f64x2<S>;
1114    #[inline(always)]
1115    fn sub(self, rhs: f64x2<S>) -> Self::Output {
1116        rhs.simd.sub_f64x2(self.simd_into(rhs.simd), rhs)
1117    }
1118}
1119impl<S: Simd> core::ops::Mul for f64x2<S> {
1120    type Output = Self;
1121    #[inline(always)]
1122    fn mul(self, rhs: Self) -> Self::Output {
1123        self.simd.mul_f64x2(self, rhs)
1124    }
1125}
1126impl<S: Simd> core::ops::Mul<f64> for f64x2<S> {
1127    type Output = Self;
1128    #[inline(always)]
1129    fn mul(self, rhs: f64) -> Self::Output {
1130        self.simd.mul_f64x2(self, rhs.simd_into(self.simd))
1131    }
1132}
1133impl<S: Simd> core::ops::Mul<f64x2<S>> for f64 {
1134    type Output = f64x2<S>;
1135    #[inline(always)]
1136    fn mul(self, rhs: f64x2<S>) -> Self::Output {
1137        rhs.simd.mul_f64x2(self.simd_into(rhs.simd), rhs)
1138    }
1139}
1140impl<S: Simd> core::ops::Div for f64x2<S> {
1141    type Output = Self;
1142    #[inline(always)]
1143    fn div(self, rhs: Self) -> Self::Output {
1144        self.simd.div_f64x2(self, rhs)
1145    }
1146}
1147impl<S: Simd> core::ops::Div<f64> for f64x2<S> {
1148    type Output = Self;
1149    #[inline(always)]
1150    fn div(self, rhs: f64) -> Self::Output {
1151        self.simd.div_f64x2(self, rhs.simd_into(self.simd))
1152    }
1153}
1154impl<S: Simd> core::ops::Div<f64x2<S>> for f64 {
1155    type Output = f64x2<S>;
1156    #[inline(always)]
1157    fn div(self, rhs: f64x2<S>) -> Self::Output {
1158        rhs.simd.div_f64x2(self.simd_into(rhs.simd), rhs)
1159    }
1160}
1161impl<S: Simd> core::ops::BitAnd for mask64x2<S> {
1162    type Output = Self;
1163    #[inline(always)]
1164    fn bitand(self, rhs: Self) -> Self::Output {
1165        self.simd.and_mask64x2(self, rhs)
1166    }
1167}
1168impl<S: Simd> core::ops::BitAnd<i64> for mask64x2<S> {
1169    type Output = Self;
1170    #[inline(always)]
1171    fn bitand(self, rhs: i64) -> Self::Output {
1172        self.simd.and_mask64x2(self, rhs.simd_into(self.simd))
1173    }
1174}
1175impl<S: Simd> core::ops::BitAnd<mask64x2<S>> for i64 {
1176    type Output = mask64x2<S>;
1177    #[inline(always)]
1178    fn bitand(self, rhs: mask64x2<S>) -> Self::Output {
1179        rhs.simd.and_mask64x2(self.simd_into(rhs.simd), rhs)
1180    }
1181}
1182impl<S: Simd> core::ops::BitOr for mask64x2<S> {
1183    type Output = Self;
1184    #[inline(always)]
1185    fn bitor(self, rhs: Self) -> Self::Output {
1186        self.simd.or_mask64x2(self, rhs)
1187    }
1188}
1189impl<S: Simd> core::ops::BitOr<i64> for mask64x2<S> {
1190    type Output = Self;
1191    #[inline(always)]
1192    fn bitor(self, rhs: i64) -> Self::Output {
1193        self.simd.or_mask64x2(self, rhs.simd_into(self.simd))
1194    }
1195}
1196impl<S: Simd> core::ops::BitOr<mask64x2<S>> for i64 {
1197    type Output = mask64x2<S>;
1198    #[inline(always)]
1199    fn bitor(self, rhs: mask64x2<S>) -> Self::Output {
1200        rhs.simd.or_mask64x2(self.simd_into(rhs.simd), rhs)
1201    }
1202}
1203impl<S: Simd> core::ops::BitXor for mask64x2<S> {
1204    type Output = Self;
1205    #[inline(always)]
1206    fn bitxor(self, rhs: Self) -> Self::Output {
1207        self.simd.xor_mask64x2(self, rhs)
1208    }
1209}
1210impl<S: Simd> core::ops::BitXor<i64> for mask64x2<S> {
1211    type Output = Self;
1212    #[inline(always)]
1213    fn bitxor(self, rhs: i64) -> Self::Output {
1214        self.simd.xor_mask64x2(self, rhs.simd_into(self.simd))
1215    }
1216}
1217impl<S: Simd> core::ops::BitXor<mask64x2<S>> for i64 {
1218    type Output = mask64x2<S>;
1219    #[inline(always)]
1220    fn bitxor(self, rhs: mask64x2<S>) -> Self::Output {
1221        rhs.simd.xor_mask64x2(self.simd_into(rhs.simd), rhs)
1222    }
1223}
1224impl<S: Simd> core::ops::Not for mask64x2<S> {
1225    type Output = Self;
1226    #[inline(always)]
1227    fn not(self) -> Self::Output {
1228        self.simd.not_mask64x2(self)
1229    }
1230}
1231impl<S: Simd> core::ops::Neg for f32x8<S> {
1232    type Output = Self;
1233    #[inline(always)]
1234    fn neg(self) -> Self::Output {
1235        self.simd.neg_f32x8(self)
1236    }
1237}
1238impl<S: Simd> core::ops::Add for f32x8<S> {
1239    type Output = Self;
1240    #[inline(always)]
1241    fn add(self, rhs: Self) -> Self::Output {
1242        self.simd.add_f32x8(self, rhs)
1243    }
1244}
1245impl<S: Simd> core::ops::Add<f32> for f32x8<S> {
1246    type Output = Self;
1247    #[inline(always)]
1248    fn add(self, rhs: f32) -> Self::Output {
1249        self.simd.add_f32x8(self, rhs.simd_into(self.simd))
1250    }
1251}
1252impl<S: Simd> core::ops::Add<f32x8<S>> for f32 {
1253    type Output = f32x8<S>;
1254    #[inline(always)]
1255    fn add(self, rhs: f32x8<S>) -> Self::Output {
1256        rhs.simd.add_f32x8(self.simd_into(rhs.simd), rhs)
1257    }
1258}
1259impl<S: Simd> core::ops::Sub for f32x8<S> {
1260    type Output = Self;
1261    #[inline(always)]
1262    fn sub(self, rhs: Self) -> Self::Output {
1263        self.simd.sub_f32x8(self, rhs)
1264    }
1265}
1266impl<S: Simd> core::ops::Sub<f32> for f32x8<S> {
1267    type Output = Self;
1268    #[inline(always)]
1269    fn sub(self, rhs: f32) -> Self::Output {
1270        self.simd.sub_f32x8(self, rhs.simd_into(self.simd))
1271    }
1272}
1273impl<S: Simd> core::ops::Sub<f32x8<S>> for f32 {
1274    type Output = f32x8<S>;
1275    #[inline(always)]
1276    fn sub(self, rhs: f32x8<S>) -> Self::Output {
1277        rhs.simd.sub_f32x8(self.simd_into(rhs.simd), rhs)
1278    }
1279}
1280impl<S: Simd> core::ops::Mul for f32x8<S> {
1281    type Output = Self;
1282    #[inline(always)]
1283    fn mul(self, rhs: Self) -> Self::Output {
1284        self.simd.mul_f32x8(self, rhs)
1285    }
1286}
1287impl<S: Simd> core::ops::Mul<f32> for f32x8<S> {
1288    type Output = Self;
1289    #[inline(always)]
1290    fn mul(self, rhs: f32) -> Self::Output {
1291        self.simd.mul_f32x8(self, rhs.simd_into(self.simd))
1292    }
1293}
1294impl<S: Simd> core::ops::Mul<f32x8<S>> for f32 {
1295    type Output = f32x8<S>;
1296    #[inline(always)]
1297    fn mul(self, rhs: f32x8<S>) -> Self::Output {
1298        rhs.simd.mul_f32x8(self.simd_into(rhs.simd), rhs)
1299    }
1300}
1301impl<S: Simd> core::ops::Div for f32x8<S> {
1302    type Output = Self;
1303    #[inline(always)]
1304    fn div(self, rhs: Self) -> Self::Output {
1305        self.simd.div_f32x8(self, rhs)
1306    }
1307}
1308impl<S: Simd> core::ops::Div<f32> for f32x8<S> {
1309    type Output = Self;
1310    #[inline(always)]
1311    fn div(self, rhs: f32) -> Self::Output {
1312        self.simd.div_f32x8(self, rhs.simd_into(self.simd))
1313    }
1314}
1315impl<S: Simd> core::ops::Div<f32x8<S>> for f32 {
1316    type Output = f32x8<S>;
1317    #[inline(always)]
1318    fn div(self, rhs: f32x8<S>) -> Self::Output {
1319        rhs.simd.div_f32x8(self.simd_into(rhs.simd), rhs)
1320    }
1321}
1322impl<S: Simd> core::ops::Add for i8x32<S> {
1323    type Output = Self;
1324    #[inline(always)]
1325    fn add(self, rhs: Self) -> Self::Output {
1326        self.simd.add_i8x32(self, rhs)
1327    }
1328}
1329impl<S: Simd> core::ops::Add<i8> for i8x32<S> {
1330    type Output = Self;
1331    #[inline(always)]
1332    fn add(self, rhs: i8) -> Self::Output {
1333        self.simd.add_i8x32(self, rhs.simd_into(self.simd))
1334    }
1335}
1336impl<S: Simd> core::ops::Add<i8x32<S>> for i8 {
1337    type Output = i8x32<S>;
1338    #[inline(always)]
1339    fn add(self, rhs: i8x32<S>) -> Self::Output {
1340        rhs.simd.add_i8x32(self.simd_into(rhs.simd), rhs)
1341    }
1342}
1343impl<S: Simd> core::ops::Sub for i8x32<S> {
1344    type Output = Self;
1345    #[inline(always)]
1346    fn sub(self, rhs: Self) -> Self::Output {
1347        self.simd.sub_i8x32(self, rhs)
1348    }
1349}
1350impl<S: Simd> core::ops::Sub<i8> for i8x32<S> {
1351    type Output = Self;
1352    #[inline(always)]
1353    fn sub(self, rhs: i8) -> Self::Output {
1354        self.simd.sub_i8x32(self, rhs.simd_into(self.simd))
1355    }
1356}
1357impl<S: Simd> core::ops::Sub<i8x32<S>> for i8 {
1358    type Output = i8x32<S>;
1359    #[inline(always)]
1360    fn sub(self, rhs: i8x32<S>) -> Self::Output {
1361        rhs.simd.sub_i8x32(self.simd_into(rhs.simd), rhs)
1362    }
1363}
1364impl<S: Simd> core::ops::Mul for i8x32<S> {
1365    type Output = Self;
1366    #[inline(always)]
1367    fn mul(self, rhs: Self) -> Self::Output {
1368        self.simd.mul_i8x32(self, rhs)
1369    }
1370}
1371impl<S: Simd> core::ops::Mul<i8> for i8x32<S> {
1372    type Output = Self;
1373    #[inline(always)]
1374    fn mul(self, rhs: i8) -> Self::Output {
1375        self.simd.mul_i8x32(self, rhs.simd_into(self.simd))
1376    }
1377}
1378impl<S: Simd> core::ops::Mul<i8x32<S>> for i8 {
1379    type Output = i8x32<S>;
1380    #[inline(always)]
1381    fn mul(self, rhs: i8x32<S>) -> Self::Output {
1382        rhs.simd.mul_i8x32(self.simd_into(rhs.simd), rhs)
1383    }
1384}
1385impl<S: Simd> core::ops::BitAnd for i8x32<S> {
1386    type Output = Self;
1387    #[inline(always)]
1388    fn bitand(self, rhs: Self) -> Self::Output {
1389        self.simd.and_i8x32(self, rhs)
1390    }
1391}
1392impl<S: Simd> core::ops::BitAnd<i8> for i8x32<S> {
1393    type Output = Self;
1394    #[inline(always)]
1395    fn bitand(self, rhs: i8) -> Self::Output {
1396        self.simd.and_i8x32(self, rhs.simd_into(self.simd))
1397    }
1398}
1399impl<S: Simd> core::ops::BitAnd<i8x32<S>> for i8 {
1400    type Output = i8x32<S>;
1401    #[inline(always)]
1402    fn bitand(self, rhs: i8x32<S>) -> Self::Output {
1403        rhs.simd.and_i8x32(self.simd_into(rhs.simd), rhs)
1404    }
1405}
1406impl<S: Simd> core::ops::BitOr for i8x32<S> {
1407    type Output = Self;
1408    #[inline(always)]
1409    fn bitor(self, rhs: Self) -> Self::Output {
1410        self.simd.or_i8x32(self, rhs)
1411    }
1412}
1413impl<S: Simd> core::ops::BitOr<i8> for i8x32<S> {
1414    type Output = Self;
1415    #[inline(always)]
1416    fn bitor(self, rhs: i8) -> Self::Output {
1417        self.simd.or_i8x32(self, rhs.simd_into(self.simd))
1418    }
1419}
1420impl<S: Simd> core::ops::BitOr<i8x32<S>> for i8 {
1421    type Output = i8x32<S>;
1422    #[inline(always)]
1423    fn bitor(self, rhs: i8x32<S>) -> Self::Output {
1424        rhs.simd.or_i8x32(self.simd_into(rhs.simd), rhs)
1425    }
1426}
1427impl<S: Simd> core::ops::BitXor for i8x32<S> {
1428    type Output = Self;
1429    #[inline(always)]
1430    fn bitxor(self, rhs: Self) -> Self::Output {
1431        self.simd.xor_i8x32(self, rhs)
1432    }
1433}
1434impl<S: Simd> core::ops::BitXor<i8> for i8x32<S> {
1435    type Output = Self;
1436    #[inline(always)]
1437    fn bitxor(self, rhs: i8) -> Self::Output {
1438        self.simd.xor_i8x32(self, rhs.simd_into(self.simd))
1439    }
1440}
1441impl<S: Simd> core::ops::BitXor<i8x32<S>> for i8 {
1442    type Output = i8x32<S>;
1443    #[inline(always)]
1444    fn bitxor(self, rhs: i8x32<S>) -> Self::Output {
1445        rhs.simd.xor_i8x32(self.simd_into(rhs.simd), rhs)
1446    }
1447}
1448impl<S: Simd> core::ops::Add for u8x32<S> {
1449    type Output = Self;
1450    #[inline(always)]
1451    fn add(self, rhs: Self) -> Self::Output {
1452        self.simd.add_u8x32(self, rhs)
1453    }
1454}
1455impl<S: Simd> core::ops::Add<u8> for u8x32<S> {
1456    type Output = Self;
1457    #[inline(always)]
1458    fn add(self, rhs: u8) -> Self::Output {
1459        self.simd.add_u8x32(self, rhs.simd_into(self.simd))
1460    }
1461}
1462impl<S: Simd> core::ops::Add<u8x32<S>> for u8 {
1463    type Output = u8x32<S>;
1464    #[inline(always)]
1465    fn add(self, rhs: u8x32<S>) -> Self::Output {
1466        rhs.simd.add_u8x32(self.simd_into(rhs.simd), rhs)
1467    }
1468}
1469impl<S: Simd> core::ops::Sub for u8x32<S> {
1470    type Output = Self;
1471    #[inline(always)]
1472    fn sub(self, rhs: Self) -> Self::Output {
1473        self.simd.sub_u8x32(self, rhs)
1474    }
1475}
1476impl<S: Simd> core::ops::Sub<u8> for u8x32<S> {
1477    type Output = Self;
1478    #[inline(always)]
1479    fn sub(self, rhs: u8) -> Self::Output {
1480        self.simd.sub_u8x32(self, rhs.simd_into(self.simd))
1481    }
1482}
1483impl<S: Simd> core::ops::Sub<u8x32<S>> for u8 {
1484    type Output = u8x32<S>;
1485    #[inline(always)]
1486    fn sub(self, rhs: u8x32<S>) -> Self::Output {
1487        rhs.simd.sub_u8x32(self.simd_into(rhs.simd), rhs)
1488    }
1489}
1490impl<S: Simd> core::ops::Mul for u8x32<S> {
1491    type Output = Self;
1492    #[inline(always)]
1493    fn mul(self, rhs: Self) -> Self::Output {
1494        self.simd.mul_u8x32(self, rhs)
1495    }
1496}
1497impl<S: Simd> core::ops::Mul<u8> for u8x32<S> {
1498    type Output = Self;
1499    #[inline(always)]
1500    fn mul(self, rhs: u8) -> Self::Output {
1501        self.simd.mul_u8x32(self, rhs.simd_into(self.simd))
1502    }
1503}
1504impl<S: Simd> core::ops::Mul<u8x32<S>> for u8 {
1505    type Output = u8x32<S>;
1506    #[inline(always)]
1507    fn mul(self, rhs: u8x32<S>) -> Self::Output {
1508        rhs.simd.mul_u8x32(self.simd_into(rhs.simd), rhs)
1509    }
1510}
1511impl<S: Simd> core::ops::BitAnd for u8x32<S> {
1512    type Output = Self;
1513    #[inline(always)]
1514    fn bitand(self, rhs: Self) -> Self::Output {
1515        self.simd.and_u8x32(self, rhs)
1516    }
1517}
1518impl<S: Simd> core::ops::BitAnd<u8> for u8x32<S> {
1519    type Output = Self;
1520    #[inline(always)]
1521    fn bitand(self, rhs: u8) -> Self::Output {
1522        self.simd.and_u8x32(self, rhs.simd_into(self.simd))
1523    }
1524}
1525impl<S: Simd> core::ops::BitAnd<u8x32<S>> for u8 {
1526    type Output = u8x32<S>;
1527    #[inline(always)]
1528    fn bitand(self, rhs: u8x32<S>) -> Self::Output {
1529        rhs.simd.and_u8x32(self.simd_into(rhs.simd), rhs)
1530    }
1531}
1532impl<S: Simd> core::ops::BitOr for u8x32<S> {
1533    type Output = Self;
1534    #[inline(always)]
1535    fn bitor(self, rhs: Self) -> Self::Output {
1536        self.simd.or_u8x32(self, rhs)
1537    }
1538}
1539impl<S: Simd> core::ops::BitOr<u8> for u8x32<S> {
1540    type Output = Self;
1541    #[inline(always)]
1542    fn bitor(self, rhs: u8) -> Self::Output {
1543        self.simd.or_u8x32(self, rhs.simd_into(self.simd))
1544    }
1545}
1546impl<S: Simd> core::ops::BitOr<u8x32<S>> for u8 {
1547    type Output = u8x32<S>;
1548    #[inline(always)]
1549    fn bitor(self, rhs: u8x32<S>) -> Self::Output {
1550        rhs.simd.or_u8x32(self.simd_into(rhs.simd), rhs)
1551    }
1552}
1553impl<S: Simd> core::ops::BitXor for u8x32<S> {
1554    type Output = Self;
1555    #[inline(always)]
1556    fn bitxor(self, rhs: Self) -> Self::Output {
1557        self.simd.xor_u8x32(self, rhs)
1558    }
1559}
1560impl<S: Simd> core::ops::BitXor<u8> for u8x32<S> {
1561    type Output = Self;
1562    #[inline(always)]
1563    fn bitxor(self, rhs: u8) -> Self::Output {
1564        self.simd.xor_u8x32(self, rhs.simd_into(self.simd))
1565    }
1566}
1567impl<S: Simd> core::ops::BitXor<u8x32<S>> for u8 {
1568    type Output = u8x32<S>;
1569    #[inline(always)]
1570    fn bitxor(self, rhs: u8x32<S>) -> Self::Output {
1571        rhs.simd.xor_u8x32(self.simd_into(rhs.simd), rhs)
1572    }
1573}
1574impl<S: Simd> core::ops::BitAnd for mask8x32<S> {
1575    type Output = Self;
1576    #[inline(always)]
1577    fn bitand(self, rhs: Self) -> Self::Output {
1578        self.simd.and_mask8x32(self, rhs)
1579    }
1580}
1581impl<S: Simd> core::ops::BitAnd<i8> for mask8x32<S> {
1582    type Output = Self;
1583    #[inline(always)]
1584    fn bitand(self, rhs: i8) -> Self::Output {
1585        self.simd.and_mask8x32(self, rhs.simd_into(self.simd))
1586    }
1587}
1588impl<S: Simd> core::ops::BitAnd<mask8x32<S>> for i8 {
1589    type Output = mask8x32<S>;
1590    #[inline(always)]
1591    fn bitand(self, rhs: mask8x32<S>) -> Self::Output {
1592        rhs.simd.and_mask8x32(self.simd_into(rhs.simd), rhs)
1593    }
1594}
1595impl<S: Simd> core::ops::BitOr for mask8x32<S> {
1596    type Output = Self;
1597    #[inline(always)]
1598    fn bitor(self, rhs: Self) -> Self::Output {
1599        self.simd.or_mask8x32(self, rhs)
1600    }
1601}
1602impl<S: Simd> core::ops::BitOr<i8> for mask8x32<S> {
1603    type Output = Self;
1604    #[inline(always)]
1605    fn bitor(self, rhs: i8) -> Self::Output {
1606        self.simd.or_mask8x32(self, rhs.simd_into(self.simd))
1607    }
1608}
1609impl<S: Simd> core::ops::BitOr<mask8x32<S>> for i8 {
1610    type Output = mask8x32<S>;
1611    #[inline(always)]
1612    fn bitor(self, rhs: mask8x32<S>) -> Self::Output {
1613        rhs.simd.or_mask8x32(self.simd_into(rhs.simd), rhs)
1614    }
1615}
1616impl<S: Simd> core::ops::BitXor for mask8x32<S> {
1617    type Output = Self;
1618    #[inline(always)]
1619    fn bitxor(self, rhs: Self) -> Self::Output {
1620        self.simd.xor_mask8x32(self, rhs)
1621    }
1622}
1623impl<S: Simd> core::ops::BitXor<i8> for mask8x32<S> {
1624    type Output = Self;
1625    #[inline(always)]
1626    fn bitxor(self, rhs: i8) -> Self::Output {
1627        self.simd.xor_mask8x32(self, rhs.simd_into(self.simd))
1628    }
1629}
1630impl<S: Simd> core::ops::BitXor<mask8x32<S>> for i8 {
1631    type Output = mask8x32<S>;
1632    #[inline(always)]
1633    fn bitxor(self, rhs: mask8x32<S>) -> Self::Output {
1634        rhs.simd.xor_mask8x32(self.simd_into(rhs.simd), rhs)
1635    }
1636}
1637impl<S: Simd> core::ops::Not for mask8x32<S> {
1638    type Output = Self;
1639    #[inline(always)]
1640    fn not(self) -> Self::Output {
1641        self.simd.not_mask8x32(self)
1642    }
1643}
1644impl<S: Simd> core::ops::Add for i16x16<S> {
1645    type Output = Self;
1646    #[inline(always)]
1647    fn add(self, rhs: Self) -> Self::Output {
1648        self.simd.add_i16x16(self, rhs)
1649    }
1650}
1651impl<S: Simd> core::ops::Add<i16> for i16x16<S> {
1652    type Output = Self;
1653    #[inline(always)]
1654    fn add(self, rhs: i16) -> Self::Output {
1655        self.simd.add_i16x16(self, rhs.simd_into(self.simd))
1656    }
1657}
1658impl<S: Simd> core::ops::Add<i16x16<S>> for i16 {
1659    type Output = i16x16<S>;
1660    #[inline(always)]
1661    fn add(self, rhs: i16x16<S>) -> Self::Output {
1662        rhs.simd.add_i16x16(self.simd_into(rhs.simd), rhs)
1663    }
1664}
1665impl<S: Simd> core::ops::Sub for i16x16<S> {
1666    type Output = Self;
1667    #[inline(always)]
1668    fn sub(self, rhs: Self) -> Self::Output {
1669        self.simd.sub_i16x16(self, rhs)
1670    }
1671}
1672impl<S: Simd> core::ops::Sub<i16> for i16x16<S> {
1673    type Output = Self;
1674    #[inline(always)]
1675    fn sub(self, rhs: i16) -> Self::Output {
1676        self.simd.sub_i16x16(self, rhs.simd_into(self.simd))
1677    }
1678}
1679impl<S: Simd> core::ops::Sub<i16x16<S>> for i16 {
1680    type Output = i16x16<S>;
1681    #[inline(always)]
1682    fn sub(self, rhs: i16x16<S>) -> Self::Output {
1683        rhs.simd.sub_i16x16(self.simd_into(rhs.simd), rhs)
1684    }
1685}
1686impl<S: Simd> core::ops::Mul for i16x16<S> {
1687    type Output = Self;
1688    #[inline(always)]
1689    fn mul(self, rhs: Self) -> Self::Output {
1690        self.simd.mul_i16x16(self, rhs)
1691    }
1692}
1693impl<S: Simd> core::ops::Mul<i16> for i16x16<S> {
1694    type Output = Self;
1695    #[inline(always)]
1696    fn mul(self, rhs: i16) -> Self::Output {
1697        self.simd.mul_i16x16(self, rhs.simd_into(self.simd))
1698    }
1699}
1700impl<S: Simd> core::ops::Mul<i16x16<S>> for i16 {
1701    type Output = i16x16<S>;
1702    #[inline(always)]
1703    fn mul(self, rhs: i16x16<S>) -> Self::Output {
1704        rhs.simd.mul_i16x16(self.simd_into(rhs.simd), rhs)
1705    }
1706}
1707impl<S: Simd> core::ops::BitAnd for i16x16<S> {
1708    type Output = Self;
1709    #[inline(always)]
1710    fn bitand(self, rhs: Self) -> Self::Output {
1711        self.simd.and_i16x16(self, rhs)
1712    }
1713}
1714impl<S: Simd> core::ops::BitAnd<i16> for i16x16<S> {
1715    type Output = Self;
1716    #[inline(always)]
1717    fn bitand(self, rhs: i16) -> Self::Output {
1718        self.simd.and_i16x16(self, rhs.simd_into(self.simd))
1719    }
1720}
1721impl<S: Simd> core::ops::BitAnd<i16x16<S>> for i16 {
1722    type Output = i16x16<S>;
1723    #[inline(always)]
1724    fn bitand(self, rhs: i16x16<S>) -> Self::Output {
1725        rhs.simd.and_i16x16(self.simd_into(rhs.simd), rhs)
1726    }
1727}
1728impl<S: Simd> core::ops::BitOr for i16x16<S> {
1729    type Output = Self;
1730    #[inline(always)]
1731    fn bitor(self, rhs: Self) -> Self::Output {
1732        self.simd.or_i16x16(self, rhs)
1733    }
1734}
1735impl<S: Simd> core::ops::BitOr<i16> for i16x16<S> {
1736    type Output = Self;
1737    #[inline(always)]
1738    fn bitor(self, rhs: i16) -> Self::Output {
1739        self.simd.or_i16x16(self, rhs.simd_into(self.simd))
1740    }
1741}
1742impl<S: Simd> core::ops::BitOr<i16x16<S>> for i16 {
1743    type Output = i16x16<S>;
1744    #[inline(always)]
1745    fn bitor(self, rhs: i16x16<S>) -> Self::Output {
1746        rhs.simd.or_i16x16(self.simd_into(rhs.simd), rhs)
1747    }
1748}
1749impl<S: Simd> core::ops::BitXor for i16x16<S> {
1750    type Output = Self;
1751    #[inline(always)]
1752    fn bitxor(self, rhs: Self) -> Self::Output {
1753        self.simd.xor_i16x16(self, rhs)
1754    }
1755}
1756impl<S: Simd> core::ops::BitXor<i16> for i16x16<S> {
1757    type Output = Self;
1758    #[inline(always)]
1759    fn bitxor(self, rhs: i16) -> Self::Output {
1760        self.simd.xor_i16x16(self, rhs.simd_into(self.simd))
1761    }
1762}
1763impl<S: Simd> core::ops::BitXor<i16x16<S>> for i16 {
1764    type Output = i16x16<S>;
1765    #[inline(always)]
1766    fn bitxor(self, rhs: i16x16<S>) -> Self::Output {
1767        rhs.simd.xor_i16x16(self.simd_into(rhs.simd), rhs)
1768    }
1769}
1770impl<S: Simd> core::ops::Add for u16x16<S> {
1771    type Output = Self;
1772    #[inline(always)]
1773    fn add(self, rhs: Self) -> Self::Output {
1774        self.simd.add_u16x16(self, rhs)
1775    }
1776}
1777impl<S: Simd> core::ops::Add<u16> for u16x16<S> {
1778    type Output = Self;
1779    #[inline(always)]
1780    fn add(self, rhs: u16) -> Self::Output {
1781        self.simd.add_u16x16(self, rhs.simd_into(self.simd))
1782    }
1783}
1784impl<S: Simd> core::ops::Add<u16x16<S>> for u16 {
1785    type Output = u16x16<S>;
1786    #[inline(always)]
1787    fn add(self, rhs: u16x16<S>) -> Self::Output {
1788        rhs.simd.add_u16x16(self.simd_into(rhs.simd), rhs)
1789    }
1790}
1791impl<S: Simd> core::ops::Sub for u16x16<S> {
1792    type Output = Self;
1793    #[inline(always)]
1794    fn sub(self, rhs: Self) -> Self::Output {
1795        self.simd.sub_u16x16(self, rhs)
1796    }
1797}
1798impl<S: Simd> core::ops::Sub<u16> for u16x16<S> {
1799    type Output = Self;
1800    #[inline(always)]
1801    fn sub(self, rhs: u16) -> Self::Output {
1802        self.simd.sub_u16x16(self, rhs.simd_into(self.simd))
1803    }
1804}
1805impl<S: Simd> core::ops::Sub<u16x16<S>> for u16 {
1806    type Output = u16x16<S>;
1807    #[inline(always)]
1808    fn sub(self, rhs: u16x16<S>) -> Self::Output {
1809        rhs.simd.sub_u16x16(self.simd_into(rhs.simd), rhs)
1810    }
1811}
1812impl<S: Simd> core::ops::Mul for u16x16<S> {
1813    type Output = Self;
1814    #[inline(always)]
1815    fn mul(self, rhs: Self) -> Self::Output {
1816        self.simd.mul_u16x16(self, rhs)
1817    }
1818}
1819impl<S: Simd> core::ops::Mul<u16> for u16x16<S> {
1820    type Output = Self;
1821    #[inline(always)]
1822    fn mul(self, rhs: u16) -> Self::Output {
1823        self.simd.mul_u16x16(self, rhs.simd_into(self.simd))
1824    }
1825}
1826impl<S: Simd> core::ops::Mul<u16x16<S>> for u16 {
1827    type Output = u16x16<S>;
1828    #[inline(always)]
1829    fn mul(self, rhs: u16x16<S>) -> Self::Output {
1830        rhs.simd.mul_u16x16(self.simd_into(rhs.simd), rhs)
1831    }
1832}
1833impl<S: Simd> core::ops::BitAnd for u16x16<S> {
1834    type Output = Self;
1835    #[inline(always)]
1836    fn bitand(self, rhs: Self) -> Self::Output {
1837        self.simd.and_u16x16(self, rhs)
1838    }
1839}
1840impl<S: Simd> core::ops::BitAnd<u16> for u16x16<S> {
1841    type Output = Self;
1842    #[inline(always)]
1843    fn bitand(self, rhs: u16) -> Self::Output {
1844        self.simd.and_u16x16(self, rhs.simd_into(self.simd))
1845    }
1846}
1847impl<S: Simd> core::ops::BitAnd<u16x16<S>> for u16 {
1848    type Output = u16x16<S>;
1849    #[inline(always)]
1850    fn bitand(self, rhs: u16x16<S>) -> Self::Output {
1851        rhs.simd.and_u16x16(self.simd_into(rhs.simd), rhs)
1852    }
1853}
1854impl<S: Simd> core::ops::BitOr for u16x16<S> {
1855    type Output = Self;
1856    #[inline(always)]
1857    fn bitor(self, rhs: Self) -> Self::Output {
1858        self.simd.or_u16x16(self, rhs)
1859    }
1860}
1861impl<S: Simd> core::ops::BitOr<u16> for u16x16<S> {
1862    type Output = Self;
1863    #[inline(always)]
1864    fn bitor(self, rhs: u16) -> Self::Output {
1865        self.simd.or_u16x16(self, rhs.simd_into(self.simd))
1866    }
1867}
1868impl<S: Simd> core::ops::BitOr<u16x16<S>> for u16 {
1869    type Output = u16x16<S>;
1870    #[inline(always)]
1871    fn bitor(self, rhs: u16x16<S>) -> Self::Output {
1872        rhs.simd.or_u16x16(self.simd_into(rhs.simd), rhs)
1873    }
1874}
1875impl<S: Simd> core::ops::BitXor for u16x16<S> {
1876    type Output = Self;
1877    #[inline(always)]
1878    fn bitxor(self, rhs: Self) -> Self::Output {
1879        self.simd.xor_u16x16(self, rhs)
1880    }
1881}
1882impl<S: Simd> core::ops::BitXor<u16> for u16x16<S> {
1883    type Output = Self;
1884    #[inline(always)]
1885    fn bitxor(self, rhs: u16) -> Self::Output {
1886        self.simd.xor_u16x16(self, rhs.simd_into(self.simd))
1887    }
1888}
1889impl<S: Simd> core::ops::BitXor<u16x16<S>> for u16 {
1890    type Output = u16x16<S>;
1891    #[inline(always)]
1892    fn bitxor(self, rhs: u16x16<S>) -> Self::Output {
1893        rhs.simd.xor_u16x16(self.simd_into(rhs.simd), rhs)
1894    }
1895}
1896impl<S: Simd> core::ops::BitAnd for mask16x16<S> {
1897    type Output = Self;
1898    #[inline(always)]
1899    fn bitand(self, rhs: Self) -> Self::Output {
1900        self.simd.and_mask16x16(self, rhs)
1901    }
1902}
1903impl<S: Simd> core::ops::BitAnd<i16> for mask16x16<S> {
1904    type Output = Self;
1905    #[inline(always)]
1906    fn bitand(self, rhs: i16) -> Self::Output {
1907        self.simd.and_mask16x16(self, rhs.simd_into(self.simd))
1908    }
1909}
1910impl<S: Simd> core::ops::BitAnd<mask16x16<S>> for i16 {
1911    type Output = mask16x16<S>;
1912    #[inline(always)]
1913    fn bitand(self, rhs: mask16x16<S>) -> Self::Output {
1914        rhs.simd.and_mask16x16(self.simd_into(rhs.simd), rhs)
1915    }
1916}
1917impl<S: Simd> core::ops::BitOr for mask16x16<S> {
1918    type Output = Self;
1919    #[inline(always)]
1920    fn bitor(self, rhs: Self) -> Self::Output {
1921        self.simd.or_mask16x16(self, rhs)
1922    }
1923}
1924impl<S: Simd> core::ops::BitOr<i16> for mask16x16<S> {
1925    type Output = Self;
1926    #[inline(always)]
1927    fn bitor(self, rhs: i16) -> Self::Output {
1928        self.simd.or_mask16x16(self, rhs.simd_into(self.simd))
1929    }
1930}
1931impl<S: Simd> core::ops::BitOr<mask16x16<S>> for i16 {
1932    type Output = mask16x16<S>;
1933    #[inline(always)]
1934    fn bitor(self, rhs: mask16x16<S>) -> Self::Output {
1935        rhs.simd.or_mask16x16(self.simd_into(rhs.simd), rhs)
1936    }
1937}
1938impl<S: Simd> core::ops::BitXor for mask16x16<S> {
1939    type Output = Self;
1940    #[inline(always)]
1941    fn bitxor(self, rhs: Self) -> Self::Output {
1942        self.simd.xor_mask16x16(self, rhs)
1943    }
1944}
1945impl<S: Simd> core::ops::BitXor<i16> for mask16x16<S> {
1946    type Output = Self;
1947    #[inline(always)]
1948    fn bitxor(self, rhs: i16) -> Self::Output {
1949        self.simd.xor_mask16x16(self, rhs.simd_into(self.simd))
1950    }
1951}
1952impl<S: Simd> core::ops::BitXor<mask16x16<S>> for i16 {
1953    type Output = mask16x16<S>;
1954    #[inline(always)]
1955    fn bitxor(self, rhs: mask16x16<S>) -> Self::Output {
1956        rhs.simd.xor_mask16x16(self.simd_into(rhs.simd), rhs)
1957    }
1958}
1959impl<S: Simd> core::ops::Not for mask16x16<S> {
1960    type Output = Self;
1961    #[inline(always)]
1962    fn not(self) -> Self::Output {
1963        self.simd.not_mask16x16(self)
1964    }
1965}
1966impl<S: Simd> core::ops::Add for i32x8<S> {
1967    type Output = Self;
1968    #[inline(always)]
1969    fn add(self, rhs: Self) -> Self::Output {
1970        self.simd.add_i32x8(self, rhs)
1971    }
1972}
1973impl<S: Simd> core::ops::Add<i32> for i32x8<S> {
1974    type Output = Self;
1975    #[inline(always)]
1976    fn add(self, rhs: i32) -> Self::Output {
1977        self.simd.add_i32x8(self, rhs.simd_into(self.simd))
1978    }
1979}
1980impl<S: Simd> core::ops::Add<i32x8<S>> for i32 {
1981    type Output = i32x8<S>;
1982    #[inline(always)]
1983    fn add(self, rhs: i32x8<S>) -> Self::Output {
1984        rhs.simd.add_i32x8(self.simd_into(rhs.simd), rhs)
1985    }
1986}
1987impl<S: Simd> core::ops::Sub for i32x8<S> {
1988    type Output = Self;
1989    #[inline(always)]
1990    fn sub(self, rhs: Self) -> Self::Output {
1991        self.simd.sub_i32x8(self, rhs)
1992    }
1993}
1994impl<S: Simd> core::ops::Sub<i32> for i32x8<S> {
1995    type Output = Self;
1996    #[inline(always)]
1997    fn sub(self, rhs: i32) -> Self::Output {
1998        self.simd.sub_i32x8(self, rhs.simd_into(self.simd))
1999    }
2000}
2001impl<S: Simd> core::ops::Sub<i32x8<S>> for i32 {
2002    type Output = i32x8<S>;
2003    #[inline(always)]
2004    fn sub(self, rhs: i32x8<S>) -> Self::Output {
2005        rhs.simd.sub_i32x8(self.simd_into(rhs.simd), rhs)
2006    }
2007}
2008impl<S: Simd> core::ops::Mul for i32x8<S> {
2009    type Output = Self;
2010    #[inline(always)]
2011    fn mul(self, rhs: Self) -> Self::Output {
2012        self.simd.mul_i32x8(self, rhs)
2013    }
2014}
2015impl<S: Simd> core::ops::Mul<i32> for i32x8<S> {
2016    type Output = Self;
2017    #[inline(always)]
2018    fn mul(self, rhs: i32) -> Self::Output {
2019        self.simd.mul_i32x8(self, rhs.simd_into(self.simd))
2020    }
2021}
2022impl<S: Simd> core::ops::Mul<i32x8<S>> for i32 {
2023    type Output = i32x8<S>;
2024    #[inline(always)]
2025    fn mul(self, rhs: i32x8<S>) -> Self::Output {
2026        rhs.simd.mul_i32x8(self.simd_into(rhs.simd), rhs)
2027    }
2028}
2029impl<S: Simd> core::ops::BitAnd for i32x8<S> {
2030    type Output = Self;
2031    #[inline(always)]
2032    fn bitand(self, rhs: Self) -> Self::Output {
2033        self.simd.and_i32x8(self, rhs)
2034    }
2035}
2036impl<S: Simd> core::ops::BitAnd<i32> for i32x8<S> {
2037    type Output = Self;
2038    #[inline(always)]
2039    fn bitand(self, rhs: i32) -> Self::Output {
2040        self.simd.and_i32x8(self, rhs.simd_into(self.simd))
2041    }
2042}
2043impl<S: Simd> core::ops::BitAnd<i32x8<S>> for i32 {
2044    type Output = i32x8<S>;
2045    #[inline(always)]
2046    fn bitand(self, rhs: i32x8<S>) -> Self::Output {
2047        rhs.simd.and_i32x8(self.simd_into(rhs.simd), rhs)
2048    }
2049}
2050impl<S: Simd> core::ops::BitOr for i32x8<S> {
2051    type Output = Self;
2052    #[inline(always)]
2053    fn bitor(self, rhs: Self) -> Self::Output {
2054        self.simd.or_i32x8(self, rhs)
2055    }
2056}
2057impl<S: Simd> core::ops::BitOr<i32> for i32x8<S> {
2058    type Output = Self;
2059    #[inline(always)]
2060    fn bitor(self, rhs: i32) -> Self::Output {
2061        self.simd.or_i32x8(self, rhs.simd_into(self.simd))
2062    }
2063}
2064impl<S: Simd> core::ops::BitOr<i32x8<S>> for i32 {
2065    type Output = i32x8<S>;
2066    #[inline(always)]
2067    fn bitor(self, rhs: i32x8<S>) -> Self::Output {
2068        rhs.simd.or_i32x8(self.simd_into(rhs.simd), rhs)
2069    }
2070}
2071impl<S: Simd> core::ops::BitXor for i32x8<S> {
2072    type Output = Self;
2073    #[inline(always)]
2074    fn bitxor(self, rhs: Self) -> Self::Output {
2075        self.simd.xor_i32x8(self, rhs)
2076    }
2077}
2078impl<S: Simd> core::ops::BitXor<i32> for i32x8<S> {
2079    type Output = Self;
2080    #[inline(always)]
2081    fn bitxor(self, rhs: i32) -> Self::Output {
2082        self.simd.xor_i32x8(self, rhs.simd_into(self.simd))
2083    }
2084}
2085impl<S: Simd> core::ops::BitXor<i32x8<S>> for i32 {
2086    type Output = i32x8<S>;
2087    #[inline(always)]
2088    fn bitxor(self, rhs: i32x8<S>) -> Self::Output {
2089        rhs.simd.xor_i32x8(self.simd_into(rhs.simd), rhs)
2090    }
2091}
2092impl<S: Simd> core::ops::Add for u32x8<S> {
2093    type Output = Self;
2094    #[inline(always)]
2095    fn add(self, rhs: Self) -> Self::Output {
2096        self.simd.add_u32x8(self, rhs)
2097    }
2098}
2099impl<S: Simd> core::ops::Add<u32> for u32x8<S> {
2100    type Output = Self;
2101    #[inline(always)]
2102    fn add(self, rhs: u32) -> Self::Output {
2103        self.simd.add_u32x8(self, rhs.simd_into(self.simd))
2104    }
2105}
2106impl<S: Simd> core::ops::Add<u32x8<S>> for u32 {
2107    type Output = u32x8<S>;
2108    #[inline(always)]
2109    fn add(self, rhs: u32x8<S>) -> Self::Output {
2110        rhs.simd.add_u32x8(self.simd_into(rhs.simd), rhs)
2111    }
2112}
2113impl<S: Simd> core::ops::Sub for u32x8<S> {
2114    type Output = Self;
2115    #[inline(always)]
2116    fn sub(self, rhs: Self) -> Self::Output {
2117        self.simd.sub_u32x8(self, rhs)
2118    }
2119}
2120impl<S: Simd> core::ops::Sub<u32> for u32x8<S> {
2121    type Output = Self;
2122    #[inline(always)]
2123    fn sub(self, rhs: u32) -> Self::Output {
2124        self.simd.sub_u32x8(self, rhs.simd_into(self.simd))
2125    }
2126}
2127impl<S: Simd> core::ops::Sub<u32x8<S>> for u32 {
2128    type Output = u32x8<S>;
2129    #[inline(always)]
2130    fn sub(self, rhs: u32x8<S>) -> Self::Output {
2131        rhs.simd.sub_u32x8(self.simd_into(rhs.simd), rhs)
2132    }
2133}
2134impl<S: Simd> core::ops::Mul for u32x8<S> {
2135    type Output = Self;
2136    #[inline(always)]
2137    fn mul(self, rhs: Self) -> Self::Output {
2138        self.simd.mul_u32x8(self, rhs)
2139    }
2140}
2141impl<S: Simd> core::ops::Mul<u32> for u32x8<S> {
2142    type Output = Self;
2143    #[inline(always)]
2144    fn mul(self, rhs: u32) -> Self::Output {
2145        self.simd.mul_u32x8(self, rhs.simd_into(self.simd))
2146    }
2147}
2148impl<S: Simd> core::ops::Mul<u32x8<S>> for u32 {
2149    type Output = u32x8<S>;
2150    #[inline(always)]
2151    fn mul(self, rhs: u32x8<S>) -> Self::Output {
2152        rhs.simd.mul_u32x8(self.simd_into(rhs.simd), rhs)
2153    }
2154}
2155impl<S: Simd> core::ops::BitAnd for u32x8<S> {
2156    type Output = Self;
2157    #[inline(always)]
2158    fn bitand(self, rhs: Self) -> Self::Output {
2159        self.simd.and_u32x8(self, rhs)
2160    }
2161}
2162impl<S: Simd> core::ops::BitAnd<u32> for u32x8<S> {
2163    type Output = Self;
2164    #[inline(always)]
2165    fn bitand(self, rhs: u32) -> Self::Output {
2166        self.simd.and_u32x8(self, rhs.simd_into(self.simd))
2167    }
2168}
2169impl<S: Simd> core::ops::BitAnd<u32x8<S>> for u32 {
2170    type Output = u32x8<S>;
2171    #[inline(always)]
2172    fn bitand(self, rhs: u32x8<S>) -> Self::Output {
2173        rhs.simd.and_u32x8(self.simd_into(rhs.simd), rhs)
2174    }
2175}
2176impl<S: Simd> core::ops::BitOr for u32x8<S> {
2177    type Output = Self;
2178    #[inline(always)]
2179    fn bitor(self, rhs: Self) -> Self::Output {
2180        self.simd.or_u32x8(self, rhs)
2181    }
2182}
2183impl<S: Simd> core::ops::BitOr<u32> for u32x8<S> {
2184    type Output = Self;
2185    #[inline(always)]
2186    fn bitor(self, rhs: u32) -> Self::Output {
2187        self.simd.or_u32x8(self, rhs.simd_into(self.simd))
2188    }
2189}
2190impl<S: Simd> core::ops::BitOr<u32x8<S>> for u32 {
2191    type Output = u32x8<S>;
2192    #[inline(always)]
2193    fn bitor(self, rhs: u32x8<S>) -> Self::Output {
2194        rhs.simd.or_u32x8(self.simd_into(rhs.simd), rhs)
2195    }
2196}
2197impl<S: Simd> core::ops::BitXor for u32x8<S> {
2198    type Output = Self;
2199    #[inline(always)]
2200    fn bitxor(self, rhs: Self) -> Self::Output {
2201        self.simd.xor_u32x8(self, rhs)
2202    }
2203}
2204impl<S: Simd> core::ops::BitXor<u32> for u32x8<S> {
2205    type Output = Self;
2206    #[inline(always)]
2207    fn bitxor(self, rhs: u32) -> Self::Output {
2208        self.simd.xor_u32x8(self, rhs.simd_into(self.simd))
2209    }
2210}
2211impl<S: Simd> core::ops::BitXor<u32x8<S>> for u32 {
2212    type Output = u32x8<S>;
2213    #[inline(always)]
2214    fn bitxor(self, rhs: u32x8<S>) -> Self::Output {
2215        rhs.simd.xor_u32x8(self.simd_into(rhs.simd), rhs)
2216    }
2217}
2218impl<S: Simd> core::ops::BitAnd for mask32x8<S> {
2219    type Output = Self;
2220    #[inline(always)]
2221    fn bitand(self, rhs: Self) -> Self::Output {
2222        self.simd.and_mask32x8(self, rhs)
2223    }
2224}
2225impl<S: Simd> core::ops::BitAnd<i32> for mask32x8<S> {
2226    type Output = Self;
2227    #[inline(always)]
2228    fn bitand(self, rhs: i32) -> Self::Output {
2229        self.simd.and_mask32x8(self, rhs.simd_into(self.simd))
2230    }
2231}
2232impl<S: Simd> core::ops::BitAnd<mask32x8<S>> for i32 {
2233    type Output = mask32x8<S>;
2234    #[inline(always)]
2235    fn bitand(self, rhs: mask32x8<S>) -> Self::Output {
2236        rhs.simd.and_mask32x8(self.simd_into(rhs.simd), rhs)
2237    }
2238}
2239impl<S: Simd> core::ops::BitOr for mask32x8<S> {
2240    type Output = Self;
2241    #[inline(always)]
2242    fn bitor(self, rhs: Self) -> Self::Output {
2243        self.simd.or_mask32x8(self, rhs)
2244    }
2245}
2246impl<S: Simd> core::ops::BitOr<i32> for mask32x8<S> {
2247    type Output = Self;
2248    #[inline(always)]
2249    fn bitor(self, rhs: i32) -> Self::Output {
2250        self.simd.or_mask32x8(self, rhs.simd_into(self.simd))
2251    }
2252}
2253impl<S: Simd> core::ops::BitOr<mask32x8<S>> for i32 {
2254    type Output = mask32x8<S>;
2255    #[inline(always)]
2256    fn bitor(self, rhs: mask32x8<S>) -> Self::Output {
2257        rhs.simd.or_mask32x8(self.simd_into(rhs.simd), rhs)
2258    }
2259}
2260impl<S: Simd> core::ops::BitXor for mask32x8<S> {
2261    type Output = Self;
2262    #[inline(always)]
2263    fn bitxor(self, rhs: Self) -> Self::Output {
2264        self.simd.xor_mask32x8(self, rhs)
2265    }
2266}
2267impl<S: Simd> core::ops::BitXor<i32> for mask32x8<S> {
2268    type Output = Self;
2269    #[inline(always)]
2270    fn bitxor(self, rhs: i32) -> Self::Output {
2271        self.simd.xor_mask32x8(self, rhs.simd_into(self.simd))
2272    }
2273}
2274impl<S: Simd> core::ops::BitXor<mask32x8<S>> for i32 {
2275    type Output = mask32x8<S>;
2276    #[inline(always)]
2277    fn bitxor(self, rhs: mask32x8<S>) -> Self::Output {
2278        rhs.simd.xor_mask32x8(self.simd_into(rhs.simd), rhs)
2279    }
2280}
2281impl<S: Simd> core::ops::Not for mask32x8<S> {
2282    type Output = Self;
2283    #[inline(always)]
2284    fn not(self) -> Self::Output {
2285        self.simd.not_mask32x8(self)
2286    }
2287}
2288impl<S: Simd> core::ops::Neg for f64x4<S> {
2289    type Output = Self;
2290    #[inline(always)]
2291    fn neg(self) -> Self::Output {
2292        self.simd.neg_f64x4(self)
2293    }
2294}
2295impl<S: Simd> core::ops::Add for f64x4<S> {
2296    type Output = Self;
2297    #[inline(always)]
2298    fn add(self, rhs: Self) -> Self::Output {
2299        self.simd.add_f64x4(self, rhs)
2300    }
2301}
2302impl<S: Simd> core::ops::Add<f64> for f64x4<S> {
2303    type Output = Self;
2304    #[inline(always)]
2305    fn add(self, rhs: f64) -> Self::Output {
2306        self.simd.add_f64x4(self, rhs.simd_into(self.simd))
2307    }
2308}
2309impl<S: Simd> core::ops::Add<f64x4<S>> for f64 {
2310    type Output = f64x4<S>;
2311    #[inline(always)]
2312    fn add(self, rhs: f64x4<S>) -> Self::Output {
2313        rhs.simd.add_f64x4(self.simd_into(rhs.simd), rhs)
2314    }
2315}
2316impl<S: Simd> core::ops::Sub for f64x4<S> {
2317    type Output = Self;
2318    #[inline(always)]
2319    fn sub(self, rhs: Self) -> Self::Output {
2320        self.simd.sub_f64x4(self, rhs)
2321    }
2322}
2323impl<S: Simd> core::ops::Sub<f64> for f64x4<S> {
2324    type Output = Self;
2325    #[inline(always)]
2326    fn sub(self, rhs: f64) -> Self::Output {
2327        self.simd.sub_f64x4(self, rhs.simd_into(self.simd))
2328    }
2329}
2330impl<S: Simd> core::ops::Sub<f64x4<S>> for f64 {
2331    type Output = f64x4<S>;
2332    #[inline(always)]
2333    fn sub(self, rhs: f64x4<S>) -> Self::Output {
2334        rhs.simd.sub_f64x4(self.simd_into(rhs.simd), rhs)
2335    }
2336}
2337impl<S: Simd> core::ops::Mul for f64x4<S> {
2338    type Output = Self;
2339    #[inline(always)]
2340    fn mul(self, rhs: Self) -> Self::Output {
2341        self.simd.mul_f64x4(self, rhs)
2342    }
2343}
2344impl<S: Simd> core::ops::Mul<f64> for f64x4<S> {
2345    type Output = Self;
2346    #[inline(always)]
2347    fn mul(self, rhs: f64) -> Self::Output {
2348        self.simd.mul_f64x4(self, rhs.simd_into(self.simd))
2349    }
2350}
2351impl<S: Simd> core::ops::Mul<f64x4<S>> for f64 {
2352    type Output = f64x4<S>;
2353    #[inline(always)]
2354    fn mul(self, rhs: f64x4<S>) -> Self::Output {
2355        rhs.simd.mul_f64x4(self.simd_into(rhs.simd), rhs)
2356    }
2357}
2358impl<S: Simd> core::ops::Div for f64x4<S> {
2359    type Output = Self;
2360    #[inline(always)]
2361    fn div(self, rhs: Self) -> Self::Output {
2362        self.simd.div_f64x4(self, rhs)
2363    }
2364}
2365impl<S: Simd> core::ops::Div<f64> for f64x4<S> {
2366    type Output = Self;
2367    #[inline(always)]
2368    fn div(self, rhs: f64) -> Self::Output {
2369        self.simd.div_f64x4(self, rhs.simd_into(self.simd))
2370    }
2371}
2372impl<S: Simd> core::ops::Div<f64x4<S>> for f64 {
2373    type Output = f64x4<S>;
2374    #[inline(always)]
2375    fn div(self, rhs: f64x4<S>) -> Self::Output {
2376        rhs.simd.div_f64x4(self.simd_into(rhs.simd), rhs)
2377    }
2378}
2379impl<S: Simd> core::ops::BitAnd for mask64x4<S> {
2380    type Output = Self;
2381    #[inline(always)]
2382    fn bitand(self, rhs: Self) -> Self::Output {
2383        self.simd.and_mask64x4(self, rhs)
2384    }
2385}
2386impl<S: Simd> core::ops::BitAnd<i64> for mask64x4<S> {
2387    type Output = Self;
2388    #[inline(always)]
2389    fn bitand(self, rhs: i64) -> Self::Output {
2390        self.simd.and_mask64x4(self, rhs.simd_into(self.simd))
2391    }
2392}
2393impl<S: Simd> core::ops::BitAnd<mask64x4<S>> for i64 {
2394    type Output = mask64x4<S>;
2395    #[inline(always)]
2396    fn bitand(self, rhs: mask64x4<S>) -> Self::Output {
2397        rhs.simd.and_mask64x4(self.simd_into(rhs.simd), rhs)
2398    }
2399}
2400impl<S: Simd> core::ops::BitOr for mask64x4<S> {
2401    type Output = Self;
2402    #[inline(always)]
2403    fn bitor(self, rhs: Self) -> Self::Output {
2404        self.simd.or_mask64x4(self, rhs)
2405    }
2406}
2407impl<S: Simd> core::ops::BitOr<i64> for mask64x4<S> {
2408    type Output = Self;
2409    #[inline(always)]
2410    fn bitor(self, rhs: i64) -> Self::Output {
2411        self.simd.or_mask64x4(self, rhs.simd_into(self.simd))
2412    }
2413}
2414impl<S: Simd> core::ops::BitOr<mask64x4<S>> for i64 {
2415    type Output = mask64x4<S>;
2416    #[inline(always)]
2417    fn bitor(self, rhs: mask64x4<S>) -> Self::Output {
2418        rhs.simd.or_mask64x4(self.simd_into(rhs.simd), rhs)
2419    }
2420}
2421impl<S: Simd> core::ops::BitXor for mask64x4<S> {
2422    type Output = Self;
2423    #[inline(always)]
2424    fn bitxor(self, rhs: Self) -> Self::Output {
2425        self.simd.xor_mask64x4(self, rhs)
2426    }
2427}
2428impl<S: Simd> core::ops::BitXor<i64> for mask64x4<S> {
2429    type Output = Self;
2430    #[inline(always)]
2431    fn bitxor(self, rhs: i64) -> Self::Output {
2432        self.simd.xor_mask64x4(self, rhs.simd_into(self.simd))
2433    }
2434}
2435impl<S: Simd> core::ops::BitXor<mask64x4<S>> for i64 {
2436    type Output = mask64x4<S>;
2437    #[inline(always)]
2438    fn bitxor(self, rhs: mask64x4<S>) -> Self::Output {
2439        rhs.simd.xor_mask64x4(self.simd_into(rhs.simd), rhs)
2440    }
2441}
2442impl<S: Simd> core::ops::Not for mask64x4<S> {
2443    type Output = Self;
2444    #[inline(always)]
2445    fn not(self) -> Self::Output {
2446        self.simd.not_mask64x4(self)
2447    }
2448}
2449impl<S: Simd> core::ops::Neg for f32x16<S> {
2450    type Output = Self;
2451    #[inline(always)]
2452    fn neg(self) -> Self::Output {
2453        self.simd.neg_f32x16(self)
2454    }
2455}
2456impl<S: Simd> core::ops::Add for f32x16<S> {
2457    type Output = Self;
2458    #[inline(always)]
2459    fn add(self, rhs: Self) -> Self::Output {
2460        self.simd.add_f32x16(self, rhs)
2461    }
2462}
2463impl<S: Simd> core::ops::Add<f32> for f32x16<S> {
2464    type Output = Self;
2465    #[inline(always)]
2466    fn add(self, rhs: f32) -> Self::Output {
2467        self.simd.add_f32x16(self, rhs.simd_into(self.simd))
2468    }
2469}
2470impl<S: Simd> core::ops::Add<f32x16<S>> for f32 {
2471    type Output = f32x16<S>;
2472    #[inline(always)]
2473    fn add(self, rhs: f32x16<S>) -> Self::Output {
2474        rhs.simd.add_f32x16(self.simd_into(rhs.simd), rhs)
2475    }
2476}
2477impl<S: Simd> core::ops::Sub for f32x16<S> {
2478    type Output = Self;
2479    #[inline(always)]
2480    fn sub(self, rhs: Self) -> Self::Output {
2481        self.simd.sub_f32x16(self, rhs)
2482    }
2483}
2484impl<S: Simd> core::ops::Sub<f32> for f32x16<S> {
2485    type Output = Self;
2486    #[inline(always)]
2487    fn sub(self, rhs: f32) -> Self::Output {
2488        self.simd.sub_f32x16(self, rhs.simd_into(self.simd))
2489    }
2490}
2491impl<S: Simd> core::ops::Sub<f32x16<S>> for f32 {
2492    type Output = f32x16<S>;
2493    #[inline(always)]
2494    fn sub(self, rhs: f32x16<S>) -> Self::Output {
2495        rhs.simd.sub_f32x16(self.simd_into(rhs.simd), rhs)
2496    }
2497}
2498impl<S: Simd> core::ops::Mul for f32x16<S> {
2499    type Output = Self;
2500    #[inline(always)]
2501    fn mul(self, rhs: Self) -> Self::Output {
2502        self.simd.mul_f32x16(self, rhs)
2503    }
2504}
2505impl<S: Simd> core::ops::Mul<f32> for f32x16<S> {
2506    type Output = Self;
2507    #[inline(always)]
2508    fn mul(self, rhs: f32) -> Self::Output {
2509        self.simd.mul_f32x16(self, rhs.simd_into(self.simd))
2510    }
2511}
2512impl<S: Simd> core::ops::Mul<f32x16<S>> for f32 {
2513    type Output = f32x16<S>;
2514    #[inline(always)]
2515    fn mul(self, rhs: f32x16<S>) -> Self::Output {
2516        rhs.simd.mul_f32x16(self.simd_into(rhs.simd), rhs)
2517    }
2518}
2519impl<S: Simd> core::ops::Div for f32x16<S> {
2520    type Output = Self;
2521    #[inline(always)]
2522    fn div(self, rhs: Self) -> Self::Output {
2523        self.simd.div_f32x16(self, rhs)
2524    }
2525}
2526impl<S: Simd> core::ops::Div<f32> for f32x16<S> {
2527    type Output = Self;
2528    #[inline(always)]
2529    fn div(self, rhs: f32) -> Self::Output {
2530        self.simd.div_f32x16(self, rhs.simd_into(self.simd))
2531    }
2532}
2533impl<S: Simd> core::ops::Div<f32x16<S>> for f32 {
2534    type Output = f32x16<S>;
2535    #[inline(always)]
2536    fn div(self, rhs: f32x16<S>) -> Self::Output {
2537        rhs.simd.div_f32x16(self.simd_into(rhs.simd), rhs)
2538    }
2539}
2540impl<S: Simd> core::ops::Add for i8x64<S> {
2541    type Output = Self;
2542    #[inline(always)]
2543    fn add(self, rhs: Self) -> Self::Output {
2544        self.simd.add_i8x64(self, rhs)
2545    }
2546}
2547impl<S: Simd> core::ops::Add<i8> for i8x64<S> {
2548    type Output = Self;
2549    #[inline(always)]
2550    fn add(self, rhs: i8) -> Self::Output {
2551        self.simd.add_i8x64(self, rhs.simd_into(self.simd))
2552    }
2553}
2554impl<S: Simd> core::ops::Add<i8x64<S>> for i8 {
2555    type Output = i8x64<S>;
2556    #[inline(always)]
2557    fn add(self, rhs: i8x64<S>) -> Self::Output {
2558        rhs.simd.add_i8x64(self.simd_into(rhs.simd), rhs)
2559    }
2560}
2561impl<S: Simd> core::ops::Sub for i8x64<S> {
2562    type Output = Self;
2563    #[inline(always)]
2564    fn sub(self, rhs: Self) -> Self::Output {
2565        self.simd.sub_i8x64(self, rhs)
2566    }
2567}
2568impl<S: Simd> core::ops::Sub<i8> for i8x64<S> {
2569    type Output = Self;
2570    #[inline(always)]
2571    fn sub(self, rhs: i8) -> Self::Output {
2572        self.simd.sub_i8x64(self, rhs.simd_into(self.simd))
2573    }
2574}
2575impl<S: Simd> core::ops::Sub<i8x64<S>> for i8 {
2576    type Output = i8x64<S>;
2577    #[inline(always)]
2578    fn sub(self, rhs: i8x64<S>) -> Self::Output {
2579        rhs.simd.sub_i8x64(self.simd_into(rhs.simd), rhs)
2580    }
2581}
2582impl<S: Simd> core::ops::Mul for i8x64<S> {
2583    type Output = Self;
2584    #[inline(always)]
2585    fn mul(self, rhs: Self) -> Self::Output {
2586        self.simd.mul_i8x64(self, rhs)
2587    }
2588}
2589impl<S: Simd> core::ops::Mul<i8> for i8x64<S> {
2590    type Output = Self;
2591    #[inline(always)]
2592    fn mul(self, rhs: i8) -> Self::Output {
2593        self.simd.mul_i8x64(self, rhs.simd_into(self.simd))
2594    }
2595}
2596impl<S: Simd> core::ops::Mul<i8x64<S>> for i8 {
2597    type Output = i8x64<S>;
2598    #[inline(always)]
2599    fn mul(self, rhs: i8x64<S>) -> Self::Output {
2600        rhs.simd.mul_i8x64(self.simd_into(rhs.simd), rhs)
2601    }
2602}
2603impl<S: Simd> core::ops::BitAnd for i8x64<S> {
2604    type Output = Self;
2605    #[inline(always)]
2606    fn bitand(self, rhs: Self) -> Self::Output {
2607        self.simd.and_i8x64(self, rhs)
2608    }
2609}
2610impl<S: Simd> core::ops::BitAnd<i8> for i8x64<S> {
2611    type Output = Self;
2612    #[inline(always)]
2613    fn bitand(self, rhs: i8) -> Self::Output {
2614        self.simd.and_i8x64(self, rhs.simd_into(self.simd))
2615    }
2616}
2617impl<S: Simd> core::ops::BitAnd<i8x64<S>> for i8 {
2618    type Output = i8x64<S>;
2619    #[inline(always)]
2620    fn bitand(self, rhs: i8x64<S>) -> Self::Output {
2621        rhs.simd.and_i8x64(self.simd_into(rhs.simd), rhs)
2622    }
2623}
2624impl<S: Simd> core::ops::BitOr for i8x64<S> {
2625    type Output = Self;
2626    #[inline(always)]
2627    fn bitor(self, rhs: Self) -> Self::Output {
2628        self.simd.or_i8x64(self, rhs)
2629    }
2630}
2631impl<S: Simd> core::ops::BitOr<i8> for i8x64<S> {
2632    type Output = Self;
2633    #[inline(always)]
2634    fn bitor(self, rhs: i8) -> Self::Output {
2635        self.simd.or_i8x64(self, rhs.simd_into(self.simd))
2636    }
2637}
2638impl<S: Simd> core::ops::BitOr<i8x64<S>> for i8 {
2639    type Output = i8x64<S>;
2640    #[inline(always)]
2641    fn bitor(self, rhs: i8x64<S>) -> Self::Output {
2642        rhs.simd.or_i8x64(self.simd_into(rhs.simd), rhs)
2643    }
2644}
2645impl<S: Simd> core::ops::BitXor for i8x64<S> {
2646    type Output = Self;
2647    #[inline(always)]
2648    fn bitxor(self, rhs: Self) -> Self::Output {
2649        self.simd.xor_i8x64(self, rhs)
2650    }
2651}
2652impl<S: Simd> core::ops::BitXor<i8> for i8x64<S> {
2653    type Output = Self;
2654    #[inline(always)]
2655    fn bitxor(self, rhs: i8) -> Self::Output {
2656        self.simd.xor_i8x64(self, rhs.simd_into(self.simd))
2657    }
2658}
2659impl<S: Simd> core::ops::BitXor<i8x64<S>> for i8 {
2660    type Output = i8x64<S>;
2661    #[inline(always)]
2662    fn bitxor(self, rhs: i8x64<S>) -> Self::Output {
2663        rhs.simd.xor_i8x64(self.simd_into(rhs.simd), rhs)
2664    }
2665}
2666impl<S: Simd> core::ops::Add for u8x64<S> {
2667    type Output = Self;
2668    #[inline(always)]
2669    fn add(self, rhs: Self) -> Self::Output {
2670        self.simd.add_u8x64(self, rhs)
2671    }
2672}
2673impl<S: Simd> core::ops::Add<u8> for u8x64<S> {
2674    type Output = Self;
2675    #[inline(always)]
2676    fn add(self, rhs: u8) -> Self::Output {
2677        self.simd.add_u8x64(self, rhs.simd_into(self.simd))
2678    }
2679}
2680impl<S: Simd> core::ops::Add<u8x64<S>> for u8 {
2681    type Output = u8x64<S>;
2682    #[inline(always)]
2683    fn add(self, rhs: u8x64<S>) -> Self::Output {
2684        rhs.simd.add_u8x64(self.simd_into(rhs.simd), rhs)
2685    }
2686}
2687impl<S: Simd> core::ops::Sub for u8x64<S> {
2688    type Output = Self;
2689    #[inline(always)]
2690    fn sub(self, rhs: Self) -> Self::Output {
2691        self.simd.sub_u8x64(self, rhs)
2692    }
2693}
2694impl<S: Simd> core::ops::Sub<u8> for u8x64<S> {
2695    type Output = Self;
2696    #[inline(always)]
2697    fn sub(self, rhs: u8) -> Self::Output {
2698        self.simd.sub_u8x64(self, rhs.simd_into(self.simd))
2699    }
2700}
2701impl<S: Simd> core::ops::Sub<u8x64<S>> for u8 {
2702    type Output = u8x64<S>;
2703    #[inline(always)]
2704    fn sub(self, rhs: u8x64<S>) -> Self::Output {
2705        rhs.simd.sub_u8x64(self.simd_into(rhs.simd), rhs)
2706    }
2707}
2708impl<S: Simd> core::ops::Mul for u8x64<S> {
2709    type Output = Self;
2710    #[inline(always)]
2711    fn mul(self, rhs: Self) -> Self::Output {
2712        self.simd.mul_u8x64(self, rhs)
2713    }
2714}
2715impl<S: Simd> core::ops::Mul<u8> for u8x64<S> {
2716    type Output = Self;
2717    #[inline(always)]
2718    fn mul(self, rhs: u8) -> Self::Output {
2719        self.simd.mul_u8x64(self, rhs.simd_into(self.simd))
2720    }
2721}
2722impl<S: Simd> core::ops::Mul<u8x64<S>> for u8 {
2723    type Output = u8x64<S>;
2724    #[inline(always)]
2725    fn mul(self, rhs: u8x64<S>) -> Self::Output {
2726        rhs.simd.mul_u8x64(self.simd_into(rhs.simd), rhs)
2727    }
2728}
2729impl<S: Simd> core::ops::BitAnd for u8x64<S> {
2730    type Output = Self;
2731    #[inline(always)]
2732    fn bitand(self, rhs: Self) -> Self::Output {
2733        self.simd.and_u8x64(self, rhs)
2734    }
2735}
2736impl<S: Simd> core::ops::BitAnd<u8> for u8x64<S> {
2737    type Output = Self;
2738    #[inline(always)]
2739    fn bitand(self, rhs: u8) -> Self::Output {
2740        self.simd.and_u8x64(self, rhs.simd_into(self.simd))
2741    }
2742}
2743impl<S: Simd> core::ops::BitAnd<u8x64<S>> for u8 {
2744    type Output = u8x64<S>;
2745    #[inline(always)]
2746    fn bitand(self, rhs: u8x64<S>) -> Self::Output {
2747        rhs.simd.and_u8x64(self.simd_into(rhs.simd), rhs)
2748    }
2749}
2750impl<S: Simd> core::ops::BitOr for u8x64<S> {
2751    type Output = Self;
2752    #[inline(always)]
2753    fn bitor(self, rhs: Self) -> Self::Output {
2754        self.simd.or_u8x64(self, rhs)
2755    }
2756}
2757impl<S: Simd> core::ops::BitOr<u8> for u8x64<S> {
2758    type Output = Self;
2759    #[inline(always)]
2760    fn bitor(self, rhs: u8) -> Self::Output {
2761        self.simd.or_u8x64(self, rhs.simd_into(self.simd))
2762    }
2763}
2764impl<S: Simd> core::ops::BitOr<u8x64<S>> for u8 {
2765    type Output = u8x64<S>;
2766    #[inline(always)]
2767    fn bitor(self, rhs: u8x64<S>) -> Self::Output {
2768        rhs.simd.or_u8x64(self.simd_into(rhs.simd), rhs)
2769    }
2770}
2771impl<S: Simd> core::ops::BitXor for u8x64<S> {
2772    type Output = Self;
2773    #[inline(always)]
2774    fn bitxor(self, rhs: Self) -> Self::Output {
2775        self.simd.xor_u8x64(self, rhs)
2776    }
2777}
2778impl<S: Simd> core::ops::BitXor<u8> for u8x64<S> {
2779    type Output = Self;
2780    #[inline(always)]
2781    fn bitxor(self, rhs: u8) -> Self::Output {
2782        self.simd.xor_u8x64(self, rhs.simd_into(self.simd))
2783    }
2784}
2785impl<S: Simd> core::ops::BitXor<u8x64<S>> for u8 {
2786    type Output = u8x64<S>;
2787    #[inline(always)]
2788    fn bitxor(self, rhs: u8x64<S>) -> Self::Output {
2789        rhs.simd.xor_u8x64(self.simd_into(rhs.simd), rhs)
2790    }
2791}
2792impl<S: Simd> core::ops::BitAnd for mask8x64<S> {
2793    type Output = Self;
2794    #[inline(always)]
2795    fn bitand(self, rhs: Self) -> Self::Output {
2796        self.simd.and_mask8x64(self, rhs)
2797    }
2798}
2799impl<S: Simd> core::ops::BitAnd<i8> for mask8x64<S> {
2800    type Output = Self;
2801    #[inline(always)]
2802    fn bitand(self, rhs: i8) -> Self::Output {
2803        self.simd.and_mask8x64(self, rhs.simd_into(self.simd))
2804    }
2805}
2806impl<S: Simd> core::ops::BitAnd<mask8x64<S>> for i8 {
2807    type Output = mask8x64<S>;
2808    #[inline(always)]
2809    fn bitand(self, rhs: mask8x64<S>) -> Self::Output {
2810        rhs.simd.and_mask8x64(self.simd_into(rhs.simd), rhs)
2811    }
2812}
2813impl<S: Simd> core::ops::BitOr for mask8x64<S> {
2814    type Output = Self;
2815    #[inline(always)]
2816    fn bitor(self, rhs: Self) -> Self::Output {
2817        self.simd.or_mask8x64(self, rhs)
2818    }
2819}
2820impl<S: Simd> core::ops::BitOr<i8> for mask8x64<S> {
2821    type Output = Self;
2822    #[inline(always)]
2823    fn bitor(self, rhs: i8) -> Self::Output {
2824        self.simd.or_mask8x64(self, rhs.simd_into(self.simd))
2825    }
2826}
2827impl<S: Simd> core::ops::BitOr<mask8x64<S>> for i8 {
2828    type Output = mask8x64<S>;
2829    #[inline(always)]
2830    fn bitor(self, rhs: mask8x64<S>) -> Self::Output {
2831        rhs.simd.or_mask8x64(self.simd_into(rhs.simd), rhs)
2832    }
2833}
2834impl<S: Simd> core::ops::BitXor for mask8x64<S> {
2835    type Output = Self;
2836    #[inline(always)]
2837    fn bitxor(self, rhs: Self) -> Self::Output {
2838        self.simd.xor_mask8x64(self, rhs)
2839    }
2840}
2841impl<S: Simd> core::ops::BitXor<i8> for mask8x64<S> {
2842    type Output = Self;
2843    #[inline(always)]
2844    fn bitxor(self, rhs: i8) -> Self::Output {
2845        self.simd.xor_mask8x64(self, rhs.simd_into(self.simd))
2846    }
2847}
2848impl<S: Simd> core::ops::BitXor<mask8x64<S>> for i8 {
2849    type Output = mask8x64<S>;
2850    #[inline(always)]
2851    fn bitxor(self, rhs: mask8x64<S>) -> Self::Output {
2852        rhs.simd.xor_mask8x64(self.simd_into(rhs.simd), rhs)
2853    }
2854}
2855impl<S: Simd> core::ops::Not for mask8x64<S> {
2856    type Output = Self;
2857    #[inline(always)]
2858    fn not(self) -> Self::Output {
2859        self.simd.not_mask8x64(self)
2860    }
2861}
2862impl<S: Simd> core::ops::Add for i16x32<S> {
2863    type Output = Self;
2864    #[inline(always)]
2865    fn add(self, rhs: Self) -> Self::Output {
2866        self.simd.add_i16x32(self, rhs)
2867    }
2868}
2869impl<S: Simd> core::ops::Add<i16> for i16x32<S> {
2870    type Output = Self;
2871    #[inline(always)]
2872    fn add(self, rhs: i16) -> Self::Output {
2873        self.simd.add_i16x32(self, rhs.simd_into(self.simd))
2874    }
2875}
2876impl<S: Simd> core::ops::Add<i16x32<S>> for i16 {
2877    type Output = i16x32<S>;
2878    #[inline(always)]
2879    fn add(self, rhs: i16x32<S>) -> Self::Output {
2880        rhs.simd.add_i16x32(self.simd_into(rhs.simd), rhs)
2881    }
2882}
2883impl<S: Simd> core::ops::Sub for i16x32<S> {
2884    type Output = Self;
2885    #[inline(always)]
2886    fn sub(self, rhs: Self) -> Self::Output {
2887        self.simd.sub_i16x32(self, rhs)
2888    }
2889}
2890impl<S: Simd> core::ops::Sub<i16> for i16x32<S> {
2891    type Output = Self;
2892    #[inline(always)]
2893    fn sub(self, rhs: i16) -> Self::Output {
2894        self.simd.sub_i16x32(self, rhs.simd_into(self.simd))
2895    }
2896}
2897impl<S: Simd> core::ops::Sub<i16x32<S>> for i16 {
2898    type Output = i16x32<S>;
2899    #[inline(always)]
2900    fn sub(self, rhs: i16x32<S>) -> Self::Output {
2901        rhs.simd.sub_i16x32(self.simd_into(rhs.simd), rhs)
2902    }
2903}
2904impl<S: Simd> core::ops::Mul for i16x32<S> {
2905    type Output = Self;
2906    #[inline(always)]
2907    fn mul(self, rhs: Self) -> Self::Output {
2908        self.simd.mul_i16x32(self, rhs)
2909    }
2910}
2911impl<S: Simd> core::ops::Mul<i16> for i16x32<S> {
2912    type Output = Self;
2913    #[inline(always)]
2914    fn mul(self, rhs: i16) -> Self::Output {
2915        self.simd.mul_i16x32(self, rhs.simd_into(self.simd))
2916    }
2917}
2918impl<S: Simd> core::ops::Mul<i16x32<S>> for i16 {
2919    type Output = i16x32<S>;
2920    #[inline(always)]
2921    fn mul(self, rhs: i16x32<S>) -> Self::Output {
2922        rhs.simd.mul_i16x32(self.simd_into(rhs.simd), rhs)
2923    }
2924}
2925impl<S: Simd> core::ops::BitAnd for i16x32<S> {
2926    type Output = Self;
2927    #[inline(always)]
2928    fn bitand(self, rhs: Self) -> Self::Output {
2929        self.simd.and_i16x32(self, rhs)
2930    }
2931}
2932impl<S: Simd> core::ops::BitAnd<i16> for i16x32<S> {
2933    type Output = Self;
2934    #[inline(always)]
2935    fn bitand(self, rhs: i16) -> Self::Output {
2936        self.simd.and_i16x32(self, rhs.simd_into(self.simd))
2937    }
2938}
2939impl<S: Simd> core::ops::BitAnd<i16x32<S>> for i16 {
2940    type Output = i16x32<S>;
2941    #[inline(always)]
2942    fn bitand(self, rhs: i16x32<S>) -> Self::Output {
2943        rhs.simd.and_i16x32(self.simd_into(rhs.simd), rhs)
2944    }
2945}
2946impl<S: Simd> core::ops::BitOr for i16x32<S> {
2947    type Output = Self;
2948    #[inline(always)]
2949    fn bitor(self, rhs: Self) -> Self::Output {
2950        self.simd.or_i16x32(self, rhs)
2951    }
2952}
2953impl<S: Simd> core::ops::BitOr<i16> for i16x32<S> {
2954    type Output = Self;
2955    #[inline(always)]
2956    fn bitor(self, rhs: i16) -> Self::Output {
2957        self.simd.or_i16x32(self, rhs.simd_into(self.simd))
2958    }
2959}
2960impl<S: Simd> core::ops::BitOr<i16x32<S>> for i16 {
2961    type Output = i16x32<S>;
2962    #[inline(always)]
2963    fn bitor(self, rhs: i16x32<S>) -> Self::Output {
2964        rhs.simd.or_i16x32(self.simd_into(rhs.simd), rhs)
2965    }
2966}
2967impl<S: Simd> core::ops::BitXor for i16x32<S> {
2968    type Output = Self;
2969    #[inline(always)]
2970    fn bitxor(self, rhs: Self) -> Self::Output {
2971        self.simd.xor_i16x32(self, rhs)
2972    }
2973}
2974impl<S: Simd> core::ops::BitXor<i16> for i16x32<S> {
2975    type Output = Self;
2976    #[inline(always)]
2977    fn bitxor(self, rhs: i16) -> Self::Output {
2978        self.simd.xor_i16x32(self, rhs.simd_into(self.simd))
2979    }
2980}
2981impl<S: Simd> core::ops::BitXor<i16x32<S>> for i16 {
2982    type Output = i16x32<S>;
2983    #[inline(always)]
2984    fn bitxor(self, rhs: i16x32<S>) -> Self::Output {
2985        rhs.simd.xor_i16x32(self.simd_into(rhs.simd), rhs)
2986    }
2987}
2988impl<S: Simd> core::ops::Add for u16x32<S> {
2989    type Output = Self;
2990    #[inline(always)]
2991    fn add(self, rhs: Self) -> Self::Output {
2992        self.simd.add_u16x32(self, rhs)
2993    }
2994}
2995impl<S: Simd> core::ops::Add<u16> for u16x32<S> {
2996    type Output = Self;
2997    #[inline(always)]
2998    fn add(self, rhs: u16) -> Self::Output {
2999        self.simd.add_u16x32(self, rhs.simd_into(self.simd))
3000    }
3001}
3002impl<S: Simd> core::ops::Add<u16x32<S>> for u16 {
3003    type Output = u16x32<S>;
3004    #[inline(always)]
3005    fn add(self, rhs: u16x32<S>) -> Self::Output {
3006        rhs.simd.add_u16x32(self.simd_into(rhs.simd), rhs)
3007    }
3008}
3009impl<S: Simd> core::ops::Sub for u16x32<S> {
3010    type Output = Self;
3011    #[inline(always)]
3012    fn sub(self, rhs: Self) -> Self::Output {
3013        self.simd.sub_u16x32(self, rhs)
3014    }
3015}
3016impl<S: Simd> core::ops::Sub<u16> for u16x32<S> {
3017    type Output = Self;
3018    #[inline(always)]
3019    fn sub(self, rhs: u16) -> Self::Output {
3020        self.simd.sub_u16x32(self, rhs.simd_into(self.simd))
3021    }
3022}
3023impl<S: Simd> core::ops::Sub<u16x32<S>> for u16 {
3024    type Output = u16x32<S>;
3025    #[inline(always)]
3026    fn sub(self, rhs: u16x32<S>) -> Self::Output {
3027        rhs.simd.sub_u16x32(self.simd_into(rhs.simd), rhs)
3028    }
3029}
3030impl<S: Simd> core::ops::Mul for u16x32<S> {
3031    type Output = Self;
3032    #[inline(always)]
3033    fn mul(self, rhs: Self) -> Self::Output {
3034        self.simd.mul_u16x32(self, rhs)
3035    }
3036}
3037impl<S: Simd> core::ops::Mul<u16> for u16x32<S> {
3038    type Output = Self;
3039    #[inline(always)]
3040    fn mul(self, rhs: u16) -> Self::Output {
3041        self.simd.mul_u16x32(self, rhs.simd_into(self.simd))
3042    }
3043}
3044impl<S: Simd> core::ops::Mul<u16x32<S>> for u16 {
3045    type Output = u16x32<S>;
3046    #[inline(always)]
3047    fn mul(self, rhs: u16x32<S>) -> Self::Output {
3048        rhs.simd.mul_u16x32(self.simd_into(rhs.simd), rhs)
3049    }
3050}
3051impl<S: Simd> core::ops::BitAnd for u16x32<S> {
3052    type Output = Self;
3053    #[inline(always)]
3054    fn bitand(self, rhs: Self) -> Self::Output {
3055        self.simd.and_u16x32(self, rhs)
3056    }
3057}
3058impl<S: Simd> core::ops::BitAnd<u16> for u16x32<S> {
3059    type Output = Self;
3060    #[inline(always)]
3061    fn bitand(self, rhs: u16) -> Self::Output {
3062        self.simd.and_u16x32(self, rhs.simd_into(self.simd))
3063    }
3064}
3065impl<S: Simd> core::ops::BitAnd<u16x32<S>> for u16 {
3066    type Output = u16x32<S>;
3067    #[inline(always)]
3068    fn bitand(self, rhs: u16x32<S>) -> Self::Output {
3069        rhs.simd.and_u16x32(self.simd_into(rhs.simd), rhs)
3070    }
3071}
3072impl<S: Simd> core::ops::BitOr for u16x32<S> {
3073    type Output = Self;
3074    #[inline(always)]
3075    fn bitor(self, rhs: Self) -> Self::Output {
3076        self.simd.or_u16x32(self, rhs)
3077    }
3078}
3079impl<S: Simd> core::ops::BitOr<u16> for u16x32<S> {
3080    type Output = Self;
3081    #[inline(always)]
3082    fn bitor(self, rhs: u16) -> Self::Output {
3083        self.simd.or_u16x32(self, rhs.simd_into(self.simd))
3084    }
3085}
3086impl<S: Simd> core::ops::BitOr<u16x32<S>> for u16 {
3087    type Output = u16x32<S>;
3088    #[inline(always)]
3089    fn bitor(self, rhs: u16x32<S>) -> Self::Output {
3090        rhs.simd.or_u16x32(self.simd_into(rhs.simd), rhs)
3091    }
3092}
3093impl<S: Simd> core::ops::BitXor for u16x32<S> {
3094    type Output = Self;
3095    #[inline(always)]
3096    fn bitxor(self, rhs: Self) -> Self::Output {
3097        self.simd.xor_u16x32(self, rhs)
3098    }
3099}
3100impl<S: Simd> core::ops::BitXor<u16> for u16x32<S> {
3101    type Output = Self;
3102    #[inline(always)]
3103    fn bitxor(self, rhs: u16) -> Self::Output {
3104        self.simd.xor_u16x32(self, rhs.simd_into(self.simd))
3105    }
3106}
3107impl<S: Simd> core::ops::BitXor<u16x32<S>> for u16 {
3108    type Output = u16x32<S>;
3109    #[inline(always)]
3110    fn bitxor(self, rhs: u16x32<S>) -> Self::Output {
3111        rhs.simd.xor_u16x32(self.simd_into(rhs.simd), rhs)
3112    }
3113}
3114impl<S: Simd> core::ops::BitAnd for mask16x32<S> {
3115    type Output = Self;
3116    #[inline(always)]
3117    fn bitand(self, rhs: Self) -> Self::Output {
3118        self.simd.and_mask16x32(self, rhs)
3119    }
3120}
3121impl<S: Simd> core::ops::BitAnd<i16> for mask16x32<S> {
3122    type Output = Self;
3123    #[inline(always)]
3124    fn bitand(self, rhs: i16) -> Self::Output {
3125        self.simd.and_mask16x32(self, rhs.simd_into(self.simd))
3126    }
3127}
3128impl<S: Simd> core::ops::BitAnd<mask16x32<S>> for i16 {
3129    type Output = mask16x32<S>;
3130    #[inline(always)]
3131    fn bitand(self, rhs: mask16x32<S>) -> Self::Output {
3132        rhs.simd.and_mask16x32(self.simd_into(rhs.simd), rhs)
3133    }
3134}
3135impl<S: Simd> core::ops::BitOr for mask16x32<S> {
3136    type Output = Self;
3137    #[inline(always)]
3138    fn bitor(self, rhs: Self) -> Self::Output {
3139        self.simd.or_mask16x32(self, rhs)
3140    }
3141}
3142impl<S: Simd> core::ops::BitOr<i16> for mask16x32<S> {
3143    type Output = Self;
3144    #[inline(always)]
3145    fn bitor(self, rhs: i16) -> Self::Output {
3146        self.simd.or_mask16x32(self, rhs.simd_into(self.simd))
3147    }
3148}
3149impl<S: Simd> core::ops::BitOr<mask16x32<S>> for i16 {
3150    type Output = mask16x32<S>;
3151    #[inline(always)]
3152    fn bitor(self, rhs: mask16x32<S>) -> Self::Output {
3153        rhs.simd.or_mask16x32(self.simd_into(rhs.simd), rhs)
3154    }
3155}
3156impl<S: Simd> core::ops::BitXor for mask16x32<S> {
3157    type Output = Self;
3158    #[inline(always)]
3159    fn bitxor(self, rhs: Self) -> Self::Output {
3160        self.simd.xor_mask16x32(self, rhs)
3161    }
3162}
3163impl<S: Simd> core::ops::BitXor<i16> for mask16x32<S> {
3164    type Output = Self;
3165    #[inline(always)]
3166    fn bitxor(self, rhs: i16) -> Self::Output {
3167        self.simd.xor_mask16x32(self, rhs.simd_into(self.simd))
3168    }
3169}
3170impl<S: Simd> core::ops::BitXor<mask16x32<S>> for i16 {
3171    type Output = mask16x32<S>;
3172    #[inline(always)]
3173    fn bitxor(self, rhs: mask16x32<S>) -> Self::Output {
3174        rhs.simd.xor_mask16x32(self.simd_into(rhs.simd), rhs)
3175    }
3176}
3177impl<S: Simd> core::ops::Not for mask16x32<S> {
3178    type Output = Self;
3179    #[inline(always)]
3180    fn not(self) -> Self::Output {
3181        self.simd.not_mask16x32(self)
3182    }
3183}
3184impl<S: Simd> core::ops::Add for i32x16<S> {
3185    type Output = Self;
3186    #[inline(always)]
3187    fn add(self, rhs: Self) -> Self::Output {
3188        self.simd.add_i32x16(self, rhs)
3189    }
3190}
3191impl<S: Simd> core::ops::Add<i32> for i32x16<S> {
3192    type Output = Self;
3193    #[inline(always)]
3194    fn add(self, rhs: i32) -> Self::Output {
3195        self.simd.add_i32x16(self, rhs.simd_into(self.simd))
3196    }
3197}
3198impl<S: Simd> core::ops::Add<i32x16<S>> for i32 {
3199    type Output = i32x16<S>;
3200    #[inline(always)]
3201    fn add(self, rhs: i32x16<S>) -> Self::Output {
3202        rhs.simd.add_i32x16(self.simd_into(rhs.simd), rhs)
3203    }
3204}
3205impl<S: Simd> core::ops::Sub for i32x16<S> {
3206    type Output = Self;
3207    #[inline(always)]
3208    fn sub(self, rhs: Self) -> Self::Output {
3209        self.simd.sub_i32x16(self, rhs)
3210    }
3211}
3212impl<S: Simd> core::ops::Sub<i32> for i32x16<S> {
3213    type Output = Self;
3214    #[inline(always)]
3215    fn sub(self, rhs: i32) -> Self::Output {
3216        self.simd.sub_i32x16(self, rhs.simd_into(self.simd))
3217    }
3218}
3219impl<S: Simd> core::ops::Sub<i32x16<S>> for i32 {
3220    type Output = i32x16<S>;
3221    #[inline(always)]
3222    fn sub(self, rhs: i32x16<S>) -> Self::Output {
3223        rhs.simd.sub_i32x16(self.simd_into(rhs.simd), rhs)
3224    }
3225}
3226impl<S: Simd> core::ops::Mul for i32x16<S> {
3227    type Output = Self;
3228    #[inline(always)]
3229    fn mul(self, rhs: Self) -> Self::Output {
3230        self.simd.mul_i32x16(self, rhs)
3231    }
3232}
3233impl<S: Simd> core::ops::Mul<i32> for i32x16<S> {
3234    type Output = Self;
3235    #[inline(always)]
3236    fn mul(self, rhs: i32) -> Self::Output {
3237        self.simd.mul_i32x16(self, rhs.simd_into(self.simd))
3238    }
3239}
3240impl<S: Simd> core::ops::Mul<i32x16<S>> for i32 {
3241    type Output = i32x16<S>;
3242    #[inline(always)]
3243    fn mul(self, rhs: i32x16<S>) -> Self::Output {
3244        rhs.simd.mul_i32x16(self.simd_into(rhs.simd), rhs)
3245    }
3246}
3247impl<S: Simd> core::ops::BitAnd for i32x16<S> {
3248    type Output = Self;
3249    #[inline(always)]
3250    fn bitand(self, rhs: Self) -> Self::Output {
3251        self.simd.and_i32x16(self, rhs)
3252    }
3253}
3254impl<S: Simd> core::ops::BitAnd<i32> for i32x16<S> {
3255    type Output = Self;
3256    #[inline(always)]
3257    fn bitand(self, rhs: i32) -> Self::Output {
3258        self.simd.and_i32x16(self, rhs.simd_into(self.simd))
3259    }
3260}
3261impl<S: Simd> core::ops::BitAnd<i32x16<S>> for i32 {
3262    type Output = i32x16<S>;
3263    #[inline(always)]
3264    fn bitand(self, rhs: i32x16<S>) -> Self::Output {
3265        rhs.simd.and_i32x16(self.simd_into(rhs.simd), rhs)
3266    }
3267}
3268impl<S: Simd> core::ops::BitOr for i32x16<S> {
3269    type Output = Self;
3270    #[inline(always)]
3271    fn bitor(self, rhs: Self) -> Self::Output {
3272        self.simd.or_i32x16(self, rhs)
3273    }
3274}
3275impl<S: Simd> core::ops::BitOr<i32> for i32x16<S> {
3276    type Output = Self;
3277    #[inline(always)]
3278    fn bitor(self, rhs: i32) -> Self::Output {
3279        self.simd.or_i32x16(self, rhs.simd_into(self.simd))
3280    }
3281}
3282impl<S: Simd> core::ops::BitOr<i32x16<S>> for i32 {
3283    type Output = i32x16<S>;
3284    #[inline(always)]
3285    fn bitor(self, rhs: i32x16<S>) -> Self::Output {
3286        rhs.simd.or_i32x16(self.simd_into(rhs.simd), rhs)
3287    }
3288}
3289impl<S: Simd> core::ops::BitXor for i32x16<S> {
3290    type Output = Self;
3291    #[inline(always)]
3292    fn bitxor(self, rhs: Self) -> Self::Output {
3293        self.simd.xor_i32x16(self, rhs)
3294    }
3295}
3296impl<S: Simd> core::ops::BitXor<i32> for i32x16<S> {
3297    type Output = Self;
3298    #[inline(always)]
3299    fn bitxor(self, rhs: i32) -> Self::Output {
3300        self.simd.xor_i32x16(self, rhs.simd_into(self.simd))
3301    }
3302}
3303impl<S: Simd> core::ops::BitXor<i32x16<S>> for i32 {
3304    type Output = i32x16<S>;
3305    #[inline(always)]
3306    fn bitxor(self, rhs: i32x16<S>) -> Self::Output {
3307        rhs.simd.xor_i32x16(self.simd_into(rhs.simd), rhs)
3308    }
3309}
3310impl<S: Simd> core::ops::Add for u32x16<S> {
3311    type Output = Self;
3312    #[inline(always)]
3313    fn add(self, rhs: Self) -> Self::Output {
3314        self.simd.add_u32x16(self, rhs)
3315    }
3316}
3317impl<S: Simd> core::ops::Add<u32> for u32x16<S> {
3318    type Output = Self;
3319    #[inline(always)]
3320    fn add(self, rhs: u32) -> Self::Output {
3321        self.simd.add_u32x16(self, rhs.simd_into(self.simd))
3322    }
3323}
3324impl<S: Simd> core::ops::Add<u32x16<S>> for u32 {
3325    type Output = u32x16<S>;
3326    #[inline(always)]
3327    fn add(self, rhs: u32x16<S>) -> Self::Output {
3328        rhs.simd.add_u32x16(self.simd_into(rhs.simd), rhs)
3329    }
3330}
3331impl<S: Simd> core::ops::Sub for u32x16<S> {
3332    type Output = Self;
3333    #[inline(always)]
3334    fn sub(self, rhs: Self) -> Self::Output {
3335        self.simd.sub_u32x16(self, rhs)
3336    }
3337}
3338impl<S: Simd> core::ops::Sub<u32> for u32x16<S> {
3339    type Output = Self;
3340    #[inline(always)]
3341    fn sub(self, rhs: u32) -> Self::Output {
3342        self.simd.sub_u32x16(self, rhs.simd_into(self.simd))
3343    }
3344}
3345impl<S: Simd> core::ops::Sub<u32x16<S>> for u32 {
3346    type Output = u32x16<S>;
3347    #[inline(always)]
3348    fn sub(self, rhs: u32x16<S>) -> Self::Output {
3349        rhs.simd.sub_u32x16(self.simd_into(rhs.simd), rhs)
3350    }
3351}
3352impl<S: Simd> core::ops::Mul for u32x16<S> {
3353    type Output = Self;
3354    #[inline(always)]
3355    fn mul(self, rhs: Self) -> Self::Output {
3356        self.simd.mul_u32x16(self, rhs)
3357    }
3358}
3359impl<S: Simd> core::ops::Mul<u32> for u32x16<S> {
3360    type Output = Self;
3361    #[inline(always)]
3362    fn mul(self, rhs: u32) -> Self::Output {
3363        self.simd.mul_u32x16(self, rhs.simd_into(self.simd))
3364    }
3365}
3366impl<S: Simd> core::ops::Mul<u32x16<S>> for u32 {
3367    type Output = u32x16<S>;
3368    #[inline(always)]
3369    fn mul(self, rhs: u32x16<S>) -> Self::Output {
3370        rhs.simd.mul_u32x16(self.simd_into(rhs.simd), rhs)
3371    }
3372}
3373impl<S: Simd> core::ops::BitAnd for u32x16<S> {
3374    type Output = Self;
3375    #[inline(always)]
3376    fn bitand(self, rhs: Self) -> Self::Output {
3377        self.simd.and_u32x16(self, rhs)
3378    }
3379}
3380impl<S: Simd> core::ops::BitAnd<u32> for u32x16<S> {
3381    type Output = Self;
3382    #[inline(always)]
3383    fn bitand(self, rhs: u32) -> Self::Output {
3384        self.simd.and_u32x16(self, rhs.simd_into(self.simd))
3385    }
3386}
3387impl<S: Simd> core::ops::BitAnd<u32x16<S>> for u32 {
3388    type Output = u32x16<S>;
3389    #[inline(always)]
3390    fn bitand(self, rhs: u32x16<S>) -> Self::Output {
3391        rhs.simd.and_u32x16(self.simd_into(rhs.simd), rhs)
3392    }
3393}
3394impl<S: Simd> core::ops::BitOr for u32x16<S> {
3395    type Output = Self;
3396    #[inline(always)]
3397    fn bitor(self, rhs: Self) -> Self::Output {
3398        self.simd.or_u32x16(self, rhs)
3399    }
3400}
3401impl<S: Simd> core::ops::BitOr<u32> for u32x16<S> {
3402    type Output = Self;
3403    #[inline(always)]
3404    fn bitor(self, rhs: u32) -> Self::Output {
3405        self.simd.or_u32x16(self, rhs.simd_into(self.simd))
3406    }
3407}
3408impl<S: Simd> core::ops::BitOr<u32x16<S>> for u32 {
3409    type Output = u32x16<S>;
3410    #[inline(always)]
3411    fn bitor(self, rhs: u32x16<S>) -> Self::Output {
3412        rhs.simd.or_u32x16(self.simd_into(rhs.simd), rhs)
3413    }
3414}
3415impl<S: Simd> core::ops::BitXor for u32x16<S> {
3416    type Output = Self;
3417    #[inline(always)]
3418    fn bitxor(self, rhs: Self) -> Self::Output {
3419        self.simd.xor_u32x16(self, rhs)
3420    }
3421}
3422impl<S: Simd> core::ops::BitXor<u32> for u32x16<S> {
3423    type Output = Self;
3424    #[inline(always)]
3425    fn bitxor(self, rhs: u32) -> Self::Output {
3426        self.simd.xor_u32x16(self, rhs.simd_into(self.simd))
3427    }
3428}
3429impl<S: Simd> core::ops::BitXor<u32x16<S>> for u32 {
3430    type Output = u32x16<S>;
3431    #[inline(always)]
3432    fn bitxor(self, rhs: u32x16<S>) -> Self::Output {
3433        rhs.simd.xor_u32x16(self.simd_into(rhs.simd), rhs)
3434    }
3435}
3436impl<S: Simd> core::ops::BitAnd for mask32x16<S> {
3437    type Output = Self;
3438    #[inline(always)]
3439    fn bitand(self, rhs: Self) -> Self::Output {
3440        self.simd.and_mask32x16(self, rhs)
3441    }
3442}
3443impl<S: Simd> core::ops::BitAnd<i32> for mask32x16<S> {
3444    type Output = Self;
3445    #[inline(always)]
3446    fn bitand(self, rhs: i32) -> Self::Output {
3447        self.simd.and_mask32x16(self, rhs.simd_into(self.simd))
3448    }
3449}
3450impl<S: Simd> core::ops::BitAnd<mask32x16<S>> for i32 {
3451    type Output = mask32x16<S>;
3452    #[inline(always)]
3453    fn bitand(self, rhs: mask32x16<S>) -> Self::Output {
3454        rhs.simd.and_mask32x16(self.simd_into(rhs.simd), rhs)
3455    }
3456}
3457impl<S: Simd> core::ops::BitOr for mask32x16<S> {
3458    type Output = Self;
3459    #[inline(always)]
3460    fn bitor(self, rhs: Self) -> Self::Output {
3461        self.simd.or_mask32x16(self, rhs)
3462    }
3463}
3464impl<S: Simd> core::ops::BitOr<i32> for mask32x16<S> {
3465    type Output = Self;
3466    #[inline(always)]
3467    fn bitor(self, rhs: i32) -> Self::Output {
3468        self.simd.or_mask32x16(self, rhs.simd_into(self.simd))
3469    }
3470}
3471impl<S: Simd> core::ops::BitOr<mask32x16<S>> for i32 {
3472    type Output = mask32x16<S>;
3473    #[inline(always)]
3474    fn bitor(self, rhs: mask32x16<S>) -> Self::Output {
3475        rhs.simd.or_mask32x16(self.simd_into(rhs.simd), rhs)
3476    }
3477}
3478impl<S: Simd> core::ops::BitXor for mask32x16<S> {
3479    type Output = Self;
3480    #[inline(always)]
3481    fn bitxor(self, rhs: Self) -> Self::Output {
3482        self.simd.xor_mask32x16(self, rhs)
3483    }
3484}
3485impl<S: Simd> core::ops::BitXor<i32> for mask32x16<S> {
3486    type Output = Self;
3487    #[inline(always)]
3488    fn bitxor(self, rhs: i32) -> Self::Output {
3489        self.simd.xor_mask32x16(self, rhs.simd_into(self.simd))
3490    }
3491}
3492impl<S: Simd> core::ops::BitXor<mask32x16<S>> for i32 {
3493    type Output = mask32x16<S>;
3494    #[inline(always)]
3495    fn bitxor(self, rhs: mask32x16<S>) -> Self::Output {
3496        rhs.simd.xor_mask32x16(self.simd_into(rhs.simd), rhs)
3497    }
3498}
3499impl<S: Simd> core::ops::Not for mask32x16<S> {
3500    type Output = Self;
3501    #[inline(always)]
3502    fn not(self) -> Self::Output {
3503        self.simd.not_mask32x16(self)
3504    }
3505}
3506impl<S: Simd> core::ops::Neg for f64x8<S> {
3507    type Output = Self;
3508    #[inline(always)]
3509    fn neg(self) -> Self::Output {
3510        self.simd.neg_f64x8(self)
3511    }
3512}
3513impl<S: Simd> core::ops::Add for f64x8<S> {
3514    type Output = Self;
3515    #[inline(always)]
3516    fn add(self, rhs: Self) -> Self::Output {
3517        self.simd.add_f64x8(self, rhs)
3518    }
3519}
3520impl<S: Simd> core::ops::Add<f64> for f64x8<S> {
3521    type Output = Self;
3522    #[inline(always)]
3523    fn add(self, rhs: f64) -> Self::Output {
3524        self.simd.add_f64x8(self, rhs.simd_into(self.simd))
3525    }
3526}
3527impl<S: Simd> core::ops::Add<f64x8<S>> for f64 {
3528    type Output = f64x8<S>;
3529    #[inline(always)]
3530    fn add(self, rhs: f64x8<S>) -> Self::Output {
3531        rhs.simd.add_f64x8(self.simd_into(rhs.simd), rhs)
3532    }
3533}
3534impl<S: Simd> core::ops::Sub for f64x8<S> {
3535    type Output = Self;
3536    #[inline(always)]
3537    fn sub(self, rhs: Self) -> Self::Output {
3538        self.simd.sub_f64x8(self, rhs)
3539    }
3540}
3541impl<S: Simd> core::ops::Sub<f64> for f64x8<S> {
3542    type Output = Self;
3543    #[inline(always)]
3544    fn sub(self, rhs: f64) -> Self::Output {
3545        self.simd.sub_f64x8(self, rhs.simd_into(self.simd))
3546    }
3547}
3548impl<S: Simd> core::ops::Sub<f64x8<S>> for f64 {
3549    type Output = f64x8<S>;
3550    #[inline(always)]
3551    fn sub(self, rhs: f64x8<S>) -> Self::Output {
3552        rhs.simd.sub_f64x8(self.simd_into(rhs.simd), rhs)
3553    }
3554}
3555impl<S: Simd> core::ops::Mul for f64x8<S> {
3556    type Output = Self;
3557    #[inline(always)]
3558    fn mul(self, rhs: Self) -> Self::Output {
3559        self.simd.mul_f64x8(self, rhs)
3560    }
3561}
3562impl<S: Simd> core::ops::Mul<f64> for f64x8<S> {
3563    type Output = Self;
3564    #[inline(always)]
3565    fn mul(self, rhs: f64) -> Self::Output {
3566        self.simd.mul_f64x8(self, rhs.simd_into(self.simd))
3567    }
3568}
3569impl<S: Simd> core::ops::Mul<f64x8<S>> for f64 {
3570    type Output = f64x8<S>;
3571    #[inline(always)]
3572    fn mul(self, rhs: f64x8<S>) -> Self::Output {
3573        rhs.simd.mul_f64x8(self.simd_into(rhs.simd), rhs)
3574    }
3575}
3576impl<S: Simd> core::ops::Div for f64x8<S> {
3577    type Output = Self;
3578    #[inline(always)]
3579    fn div(self, rhs: Self) -> Self::Output {
3580        self.simd.div_f64x8(self, rhs)
3581    }
3582}
3583impl<S: Simd> core::ops::Div<f64> for f64x8<S> {
3584    type Output = Self;
3585    #[inline(always)]
3586    fn div(self, rhs: f64) -> Self::Output {
3587        self.simd.div_f64x8(self, rhs.simd_into(self.simd))
3588    }
3589}
3590impl<S: Simd> core::ops::Div<f64x8<S>> for f64 {
3591    type Output = f64x8<S>;
3592    #[inline(always)]
3593    fn div(self, rhs: f64x8<S>) -> Self::Output {
3594        rhs.simd.div_f64x8(self.simd_into(rhs.simd), rhs)
3595    }
3596}
3597impl<S: Simd> core::ops::BitAnd for mask64x8<S> {
3598    type Output = Self;
3599    #[inline(always)]
3600    fn bitand(self, rhs: Self) -> Self::Output {
3601        self.simd.and_mask64x8(self, rhs)
3602    }
3603}
3604impl<S: Simd> core::ops::BitAnd<i64> for mask64x8<S> {
3605    type Output = Self;
3606    #[inline(always)]
3607    fn bitand(self, rhs: i64) -> Self::Output {
3608        self.simd.and_mask64x8(self, rhs.simd_into(self.simd))
3609    }
3610}
3611impl<S: Simd> core::ops::BitAnd<mask64x8<S>> for i64 {
3612    type Output = mask64x8<S>;
3613    #[inline(always)]
3614    fn bitand(self, rhs: mask64x8<S>) -> Self::Output {
3615        rhs.simd.and_mask64x8(self.simd_into(rhs.simd), rhs)
3616    }
3617}
3618impl<S: Simd> core::ops::BitOr for mask64x8<S> {
3619    type Output = Self;
3620    #[inline(always)]
3621    fn bitor(self, rhs: Self) -> Self::Output {
3622        self.simd.or_mask64x8(self, rhs)
3623    }
3624}
3625impl<S: Simd> core::ops::BitOr<i64> for mask64x8<S> {
3626    type Output = Self;
3627    #[inline(always)]
3628    fn bitor(self, rhs: i64) -> Self::Output {
3629        self.simd.or_mask64x8(self, rhs.simd_into(self.simd))
3630    }
3631}
3632impl<S: Simd> core::ops::BitOr<mask64x8<S>> for i64 {
3633    type Output = mask64x8<S>;
3634    #[inline(always)]
3635    fn bitor(self, rhs: mask64x8<S>) -> Self::Output {
3636        rhs.simd.or_mask64x8(self.simd_into(rhs.simd), rhs)
3637    }
3638}
3639impl<S: Simd> core::ops::BitXor for mask64x8<S> {
3640    type Output = Self;
3641    #[inline(always)]
3642    fn bitxor(self, rhs: Self) -> Self::Output {
3643        self.simd.xor_mask64x8(self, rhs)
3644    }
3645}
3646impl<S: Simd> core::ops::BitXor<i64> for mask64x8<S> {
3647    type Output = Self;
3648    #[inline(always)]
3649    fn bitxor(self, rhs: i64) -> Self::Output {
3650        self.simd.xor_mask64x8(self, rhs.simd_into(self.simd))
3651    }
3652}
3653impl<S: Simd> core::ops::BitXor<mask64x8<S>> for i64 {
3654    type Output = mask64x8<S>;
3655    #[inline(always)]
3656    fn bitxor(self, rhs: mask64x8<S>) -> Self::Output {
3657        rhs.simd.xor_mask64x8(self.simd_into(rhs.simd), rhs)
3658    }
3659}
3660impl<S: Simd> core::ops::Not for mask64x8<S> {
3661    type Output = Self;
3662    #[inline(always)]
3663    fn not(self) -> Self::Output {
3664        self.simd.not_mask64x8(self)
3665    }
3666}