• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Generated from swizzle_impl.rs.tera template. Edit the template, not the generated file.
2 
3 #![allow(clippy::useless_conversion)]
4 
5 use crate::{Vec2, Vec3, Vec4, Vec4Swizzles};
6 
7 use core::simd::*;
8 
9 impl Vec4Swizzles for Vec4 {
10     type Vec2 = Vec2;
11 
12     type Vec3 = Vec3;
13 
14     #[inline]
15     #[must_use]
xx(self) -> Vec216     fn xx(self) -> Vec2 {
17         Vec2 {
18             x: self.x,
19             y: self.x,
20         }
21     }
22 
23     #[inline]
24     #[must_use]
xy(self) -> Vec225     fn xy(self) -> Vec2 {
26         Vec2 {
27             x: self.x,
28             y: self.y,
29         }
30     }
31 
32     #[inline]
33     #[must_use]
with_xy(self, rhs: Vec2) -> Self34     fn with_xy(self, rhs: Vec2) -> Self {
35         Self::new(rhs.x, rhs.y, self.z, self.w)
36     }
37 
38     #[inline]
39     #[must_use]
xz(self) -> Vec240     fn xz(self) -> Vec2 {
41         Vec2 {
42             x: self.x,
43             y: self.z,
44         }
45     }
46 
47     #[inline]
48     #[must_use]
with_xz(self, rhs: Vec2) -> Self49     fn with_xz(self, rhs: Vec2) -> Self {
50         Self::new(rhs.x, self.y, rhs.y, self.w)
51     }
52 
53     #[inline]
54     #[must_use]
xw(self) -> Vec255     fn xw(self) -> Vec2 {
56         Vec2 {
57             x: self.x,
58             y: self.w,
59         }
60     }
61 
62     #[inline]
63     #[must_use]
with_xw(self, rhs: Vec2) -> Self64     fn with_xw(self, rhs: Vec2) -> Self {
65         Self::new(rhs.x, self.y, self.z, rhs.y)
66     }
67 
68     #[inline]
69     #[must_use]
yx(self) -> Vec270     fn yx(self) -> Vec2 {
71         Vec2 {
72             x: self.y,
73             y: self.x,
74         }
75     }
76 
77     #[inline]
78     #[must_use]
with_yx(self, rhs: Vec2) -> Self79     fn with_yx(self, rhs: Vec2) -> Self {
80         Self::new(rhs.y, rhs.x, self.z, self.w)
81     }
82 
83     #[inline]
84     #[must_use]
yy(self) -> Vec285     fn yy(self) -> Vec2 {
86         Vec2 {
87             x: self.y,
88             y: self.y,
89         }
90     }
91 
92     #[inline]
93     #[must_use]
yz(self) -> Vec294     fn yz(self) -> Vec2 {
95         Vec2 {
96             x: self.y,
97             y: self.z,
98         }
99     }
100 
101     #[inline]
102     #[must_use]
with_yz(self, rhs: Vec2) -> Self103     fn with_yz(self, rhs: Vec2) -> Self {
104         Self::new(self.x, rhs.x, rhs.y, self.w)
105     }
106 
107     #[inline]
108     #[must_use]
yw(self) -> Vec2109     fn yw(self) -> Vec2 {
110         Vec2 {
111             x: self.y,
112             y: self.w,
113         }
114     }
115 
116     #[inline]
117     #[must_use]
with_yw(self, rhs: Vec2) -> Self118     fn with_yw(self, rhs: Vec2) -> Self {
119         Self::new(self.x, rhs.x, self.z, rhs.y)
120     }
121 
122     #[inline]
123     #[must_use]
zx(self) -> Vec2124     fn zx(self) -> Vec2 {
125         Vec2 {
126             x: self.z,
127             y: self.x,
128         }
129     }
130 
131     #[inline]
132     #[must_use]
with_zx(self, rhs: Vec2) -> Self133     fn with_zx(self, rhs: Vec2) -> Self {
134         Self::new(rhs.y, self.y, rhs.x, self.w)
135     }
136 
137     #[inline]
138     #[must_use]
zy(self) -> Vec2139     fn zy(self) -> Vec2 {
140         Vec2 {
141             x: self.z,
142             y: self.y,
143         }
144     }
145 
146     #[inline]
147     #[must_use]
with_zy(self, rhs: Vec2) -> Self148     fn with_zy(self, rhs: Vec2) -> Self {
149         Self::new(self.x, rhs.y, rhs.x, self.w)
150     }
151 
152     #[inline]
153     #[must_use]
zz(self) -> Vec2154     fn zz(self) -> Vec2 {
155         Vec2 {
156             x: self.z,
157             y: self.z,
158         }
159     }
160 
161     #[inline]
162     #[must_use]
zw(self) -> Vec2163     fn zw(self) -> Vec2 {
164         Vec2 {
165             x: self.z,
166             y: self.w,
167         }
168     }
169 
170     #[inline]
171     #[must_use]
with_zw(self, rhs: Vec2) -> Self172     fn with_zw(self, rhs: Vec2) -> Self {
173         Self::new(self.x, self.y, rhs.x, rhs.y)
174     }
175 
176     #[inline]
177     #[must_use]
wx(self) -> Vec2178     fn wx(self) -> Vec2 {
179         Vec2 {
180             x: self.w,
181             y: self.x,
182         }
183     }
184 
185     #[inline]
186     #[must_use]
with_wx(self, rhs: Vec2) -> Self187     fn with_wx(self, rhs: Vec2) -> Self {
188         Self::new(rhs.y, self.y, self.z, rhs.x)
189     }
190 
191     #[inline]
192     #[must_use]
wy(self) -> Vec2193     fn wy(self) -> Vec2 {
194         Vec2 {
195             x: self.w,
196             y: self.y,
197         }
198     }
199 
200     #[inline]
201     #[must_use]
with_wy(self, rhs: Vec2) -> Self202     fn with_wy(self, rhs: Vec2) -> Self {
203         Self::new(self.x, rhs.y, self.z, rhs.x)
204     }
205 
206     #[inline]
207     #[must_use]
wz(self) -> Vec2208     fn wz(self) -> Vec2 {
209         Vec2 {
210             x: self.w,
211             y: self.z,
212         }
213     }
214 
215     #[inline]
216     #[must_use]
with_wz(self, rhs: Vec2) -> Self217     fn with_wz(self, rhs: Vec2) -> Self {
218         Self::new(self.x, self.y, rhs.y, rhs.x)
219     }
220 
221     #[inline]
222     #[must_use]
ww(self) -> Vec2223     fn ww(self) -> Vec2 {
224         Vec2 {
225             x: self.w,
226             y: self.w,
227         }
228     }
229 
230     #[inline]
231     #[must_use]
xxx(self) -> Vec3232     fn xxx(self) -> Vec3 {
233         Vec3::new(self.x, self.x, self.x)
234     }
235 
236     #[inline]
237     #[must_use]
xxy(self) -> Vec3238     fn xxy(self) -> Vec3 {
239         Vec3::new(self.x, self.x, self.y)
240     }
241 
242     #[inline]
243     #[must_use]
xxz(self) -> Vec3244     fn xxz(self) -> Vec3 {
245         Vec3::new(self.x, self.x, self.z)
246     }
247 
248     #[inline]
249     #[must_use]
xxw(self) -> Vec3250     fn xxw(self) -> Vec3 {
251         Vec3::new(self.x, self.x, self.w)
252     }
253 
254     #[inline]
255     #[must_use]
xyx(self) -> Vec3256     fn xyx(self) -> Vec3 {
257         Vec3::new(self.x, self.y, self.x)
258     }
259 
260     #[inline]
261     #[must_use]
xyy(self) -> Vec3262     fn xyy(self) -> Vec3 {
263         Vec3::new(self.x, self.y, self.y)
264     }
265 
266     #[inline]
267     #[must_use]
xyz(self) -> Vec3268     fn xyz(self) -> Vec3 {
269         Vec3::new(self.x, self.y, self.z)
270     }
271 
272     #[inline]
273     #[must_use]
with_xyz(self, rhs: Vec3) -> Self274     fn with_xyz(self, rhs: Vec3) -> Self {
275         Self::new(rhs.x, rhs.y, rhs.z, self.w)
276     }
277 
278     #[inline]
279     #[must_use]
xyw(self) -> Vec3280     fn xyw(self) -> Vec3 {
281         Vec3::new(self.x, self.y, self.w)
282     }
283 
284     #[inline]
285     #[must_use]
with_xyw(self, rhs: Vec3) -> Self286     fn with_xyw(self, rhs: Vec3) -> Self {
287         Self::new(rhs.x, rhs.y, self.z, rhs.z)
288     }
289 
290     #[inline]
291     #[must_use]
xzx(self) -> Vec3292     fn xzx(self) -> Vec3 {
293         Vec3::new(self.x, self.z, self.x)
294     }
295 
296     #[inline]
297     #[must_use]
xzy(self) -> Vec3298     fn xzy(self) -> Vec3 {
299         Vec3::new(self.x, self.z, self.y)
300     }
301 
302     #[inline]
303     #[must_use]
with_xzy(self, rhs: Vec3) -> Self304     fn with_xzy(self, rhs: Vec3) -> Self {
305         Self::new(rhs.x, rhs.z, rhs.y, self.w)
306     }
307 
308     #[inline]
309     #[must_use]
xzz(self) -> Vec3310     fn xzz(self) -> Vec3 {
311         Vec3::new(self.x, self.z, self.z)
312     }
313 
314     #[inline]
315     #[must_use]
xzw(self) -> Vec3316     fn xzw(self) -> Vec3 {
317         Vec3::new(self.x, self.z, self.w)
318     }
319 
320     #[inline]
321     #[must_use]
with_xzw(self, rhs: Vec3) -> Self322     fn with_xzw(self, rhs: Vec3) -> Self {
323         Self::new(rhs.x, self.y, rhs.y, rhs.z)
324     }
325 
326     #[inline]
327     #[must_use]
xwx(self) -> Vec3328     fn xwx(self) -> Vec3 {
329         Vec3::new(self.x, self.w, self.x)
330     }
331 
332     #[inline]
333     #[must_use]
xwy(self) -> Vec3334     fn xwy(self) -> Vec3 {
335         Vec3::new(self.x, self.w, self.y)
336     }
337 
338     #[inline]
339     #[must_use]
with_xwy(self, rhs: Vec3) -> Self340     fn with_xwy(self, rhs: Vec3) -> Self {
341         Self::new(rhs.x, rhs.z, self.z, rhs.y)
342     }
343 
344     #[inline]
345     #[must_use]
xwz(self) -> Vec3346     fn xwz(self) -> Vec3 {
347         Vec3::new(self.x, self.w, self.z)
348     }
349 
350     #[inline]
351     #[must_use]
with_xwz(self, rhs: Vec3) -> Self352     fn with_xwz(self, rhs: Vec3) -> Self {
353         Self::new(rhs.x, self.y, rhs.z, rhs.y)
354     }
355 
356     #[inline]
357     #[must_use]
xww(self) -> Vec3358     fn xww(self) -> Vec3 {
359         Vec3::new(self.x, self.w, self.w)
360     }
361 
362     #[inline]
363     #[must_use]
yxx(self) -> Vec3364     fn yxx(self) -> Vec3 {
365         Vec3::new(self.y, self.x, self.x)
366     }
367 
368     #[inline]
369     #[must_use]
yxy(self) -> Vec3370     fn yxy(self) -> Vec3 {
371         Vec3::new(self.y, self.x, self.y)
372     }
373 
374     #[inline]
375     #[must_use]
yxz(self) -> Vec3376     fn yxz(self) -> Vec3 {
377         Vec3::new(self.y, self.x, self.z)
378     }
379 
380     #[inline]
381     #[must_use]
with_yxz(self, rhs: Vec3) -> Self382     fn with_yxz(self, rhs: Vec3) -> Self {
383         Self::new(rhs.y, rhs.x, rhs.z, self.w)
384     }
385 
386     #[inline]
387     #[must_use]
yxw(self) -> Vec3388     fn yxw(self) -> Vec3 {
389         Vec3::new(self.y, self.x, self.w)
390     }
391 
392     #[inline]
393     #[must_use]
with_yxw(self, rhs: Vec3) -> Self394     fn with_yxw(self, rhs: Vec3) -> Self {
395         Self::new(rhs.y, rhs.x, self.z, rhs.z)
396     }
397 
398     #[inline]
399     #[must_use]
yyx(self) -> Vec3400     fn yyx(self) -> Vec3 {
401         Vec3::new(self.y, self.y, self.x)
402     }
403 
404     #[inline]
405     #[must_use]
yyy(self) -> Vec3406     fn yyy(self) -> Vec3 {
407         Vec3::new(self.y, self.y, self.y)
408     }
409 
410     #[inline]
411     #[must_use]
yyz(self) -> Vec3412     fn yyz(self) -> Vec3 {
413         Vec3::new(self.y, self.y, self.z)
414     }
415 
416     #[inline]
417     #[must_use]
yyw(self) -> Vec3418     fn yyw(self) -> Vec3 {
419         Vec3::new(self.y, self.y, self.w)
420     }
421 
422     #[inline]
423     #[must_use]
yzx(self) -> Vec3424     fn yzx(self) -> Vec3 {
425         Vec3::new(self.y, self.z, self.x)
426     }
427 
428     #[inline]
429     #[must_use]
with_yzx(self, rhs: Vec3) -> Self430     fn with_yzx(self, rhs: Vec3) -> Self {
431         Self::new(rhs.z, rhs.x, rhs.y, self.w)
432     }
433 
434     #[inline]
435     #[must_use]
yzy(self) -> Vec3436     fn yzy(self) -> Vec3 {
437         Vec3::new(self.y, self.z, self.y)
438     }
439 
440     #[inline]
441     #[must_use]
yzz(self) -> Vec3442     fn yzz(self) -> Vec3 {
443         Vec3::new(self.y, self.z, self.z)
444     }
445 
446     #[inline]
447     #[must_use]
yzw(self) -> Vec3448     fn yzw(self) -> Vec3 {
449         Vec3::new(self.y, self.z, self.w)
450     }
451 
452     #[inline]
453     #[must_use]
with_yzw(self, rhs: Vec3) -> Self454     fn with_yzw(self, rhs: Vec3) -> Self {
455         Self::new(self.x, rhs.x, rhs.y, rhs.z)
456     }
457 
458     #[inline]
459     #[must_use]
ywx(self) -> Vec3460     fn ywx(self) -> Vec3 {
461         Vec3::new(self.y, self.w, self.x)
462     }
463 
464     #[inline]
465     #[must_use]
with_ywx(self, rhs: Vec3) -> Self466     fn with_ywx(self, rhs: Vec3) -> Self {
467         Self::new(rhs.z, rhs.x, self.z, rhs.y)
468     }
469 
470     #[inline]
471     #[must_use]
ywy(self) -> Vec3472     fn ywy(self) -> Vec3 {
473         Vec3::new(self.y, self.w, self.y)
474     }
475 
476     #[inline]
477     #[must_use]
ywz(self) -> Vec3478     fn ywz(self) -> Vec3 {
479         Vec3::new(self.y, self.w, self.z)
480     }
481 
482     #[inline]
483     #[must_use]
with_ywz(self, rhs: Vec3) -> Self484     fn with_ywz(self, rhs: Vec3) -> Self {
485         Self::new(self.x, rhs.x, rhs.z, rhs.y)
486     }
487 
488     #[inline]
489     #[must_use]
yww(self) -> Vec3490     fn yww(self) -> Vec3 {
491         Vec3::new(self.y, self.w, self.w)
492     }
493 
494     #[inline]
495     #[must_use]
zxx(self) -> Vec3496     fn zxx(self) -> Vec3 {
497         Vec3::new(self.z, self.x, self.x)
498     }
499 
500     #[inline]
501     #[must_use]
zxy(self) -> Vec3502     fn zxy(self) -> Vec3 {
503         Vec3::new(self.z, self.x, self.y)
504     }
505 
506     #[inline]
507     #[must_use]
with_zxy(self, rhs: Vec3) -> Self508     fn with_zxy(self, rhs: Vec3) -> Self {
509         Self::new(rhs.y, rhs.z, rhs.x, self.w)
510     }
511 
512     #[inline]
513     #[must_use]
zxz(self) -> Vec3514     fn zxz(self) -> Vec3 {
515         Vec3::new(self.z, self.x, self.z)
516     }
517 
518     #[inline]
519     #[must_use]
zxw(self) -> Vec3520     fn zxw(self) -> Vec3 {
521         Vec3::new(self.z, self.x, self.w)
522     }
523 
524     #[inline]
525     #[must_use]
with_zxw(self, rhs: Vec3) -> Self526     fn with_zxw(self, rhs: Vec3) -> Self {
527         Self::new(rhs.y, self.y, rhs.x, rhs.z)
528     }
529 
530     #[inline]
531     #[must_use]
zyx(self) -> Vec3532     fn zyx(self) -> Vec3 {
533         Vec3::new(self.z, self.y, self.x)
534     }
535 
536     #[inline]
537     #[must_use]
with_zyx(self, rhs: Vec3) -> Self538     fn with_zyx(self, rhs: Vec3) -> Self {
539         Self::new(rhs.z, rhs.y, rhs.x, self.w)
540     }
541 
542     #[inline]
543     #[must_use]
zyy(self) -> Vec3544     fn zyy(self) -> Vec3 {
545         Vec3::new(self.z, self.y, self.y)
546     }
547 
548     #[inline]
549     #[must_use]
zyz(self) -> Vec3550     fn zyz(self) -> Vec3 {
551         Vec3::new(self.z, self.y, self.z)
552     }
553 
554     #[inline]
555     #[must_use]
zyw(self) -> Vec3556     fn zyw(self) -> Vec3 {
557         Vec3::new(self.z, self.y, self.w)
558     }
559 
560     #[inline]
561     #[must_use]
with_zyw(self, rhs: Vec3) -> Self562     fn with_zyw(self, rhs: Vec3) -> Self {
563         Self::new(self.x, rhs.y, rhs.x, rhs.z)
564     }
565 
566     #[inline]
567     #[must_use]
zzx(self) -> Vec3568     fn zzx(self) -> Vec3 {
569         Vec3::new(self.z, self.z, self.x)
570     }
571 
572     #[inline]
573     #[must_use]
zzy(self) -> Vec3574     fn zzy(self) -> Vec3 {
575         Vec3::new(self.z, self.z, self.y)
576     }
577 
578     #[inline]
579     #[must_use]
zzz(self) -> Vec3580     fn zzz(self) -> Vec3 {
581         Vec3::new(self.z, self.z, self.z)
582     }
583 
584     #[inline]
585     #[must_use]
zzw(self) -> Vec3586     fn zzw(self) -> Vec3 {
587         Vec3::new(self.z, self.z, self.w)
588     }
589 
590     #[inline]
591     #[must_use]
zwx(self) -> Vec3592     fn zwx(self) -> Vec3 {
593         Vec3::new(self.z, self.w, self.x)
594     }
595 
596     #[inline]
597     #[must_use]
with_zwx(self, rhs: Vec3) -> Self598     fn with_zwx(self, rhs: Vec3) -> Self {
599         Self::new(rhs.z, self.y, rhs.x, rhs.y)
600     }
601 
602     #[inline]
603     #[must_use]
zwy(self) -> Vec3604     fn zwy(self) -> Vec3 {
605         Vec3::new(self.z, self.w, self.y)
606     }
607 
608     #[inline]
609     #[must_use]
with_zwy(self, rhs: Vec3) -> Self610     fn with_zwy(self, rhs: Vec3) -> Self {
611         Self::new(self.x, rhs.z, rhs.x, rhs.y)
612     }
613 
614     #[inline]
615     #[must_use]
zwz(self) -> Vec3616     fn zwz(self) -> Vec3 {
617         Vec3::new(self.z, self.w, self.z)
618     }
619 
620     #[inline]
621     #[must_use]
zww(self) -> Vec3622     fn zww(self) -> Vec3 {
623         Vec3::new(self.z, self.w, self.w)
624     }
625 
626     #[inline]
627     #[must_use]
wxx(self) -> Vec3628     fn wxx(self) -> Vec3 {
629         Vec3::new(self.w, self.x, self.x)
630     }
631 
632     #[inline]
633     #[must_use]
wxy(self) -> Vec3634     fn wxy(self) -> Vec3 {
635         Vec3::new(self.w, self.x, self.y)
636     }
637 
638     #[inline]
639     #[must_use]
with_wxy(self, rhs: Vec3) -> Self640     fn with_wxy(self, rhs: Vec3) -> Self {
641         Self::new(rhs.y, rhs.z, self.z, rhs.x)
642     }
643 
644     #[inline]
645     #[must_use]
wxz(self) -> Vec3646     fn wxz(self) -> Vec3 {
647         Vec3::new(self.w, self.x, self.z)
648     }
649 
650     #[inline]
651     #[must_use]
with_wxz(self, rhs: Vec3) -> Self652     fn with_wxz(self, rhs: Vec3) -> Self {
653         Self::new(rhs.y, self.y, rhs.z, rhs.x)
654     }
655 
656     #[inline]
657     #[must_use]
wxw(self) -> Vec3658     fn wxw(self) -> Vec3 {
659         Vec3::new(self.w, self.x, self.w)
660     }
661 
662     #[inline]
663     #[must_use]
wyx(self) -> Vec3664     fn wyx(self) -> Vec3 {
665         Vec3::new(self.w, self.y, self.x)
666     }
667 
668     #[inline]
669     #[must_use]
with_wyx(self, rhs: Vec3) -> Self670     fn with_wyx(self, rhs: Vec3) -> Self {
671         Self::new(rhs.z, rhs.y, self.z, rhs.x)
672     }
673 
674     #[inline]
675     #[must_use]
wyy(self) -> Vec3676     fn wyy(self) -> Vec3 {
677         Vec3::new(self.w, self.y, self.y)
678     }
679 
680     #[inline]
681     #[must_use]
wyz(self) -> Vec3682     fn wyz(self) -> Vec3 {
683         Vec3::new(self.w, self.y, self.z)
684     }
685 
686     #[inline]
687     #[must_use]
with_wyz(self, rhs: Vec3) -> Self688     fn with_wyz(self, rhs: Vec3) -> Self {
689         Self::new(self.x, rhs.y, rhs.z, rhs.x)
690     }
691 
692     #[inline]
693     #[must_use]
wyw(self) -> Vec3694     fn wyw(self) -> Vec3 {
695         Vec3::new(self.w, self.y, self.w)
696     }
697 
698     #[inline]
699     #[must_use]
wzx(self) -> Vec3700     fn wzx(self) -> Vec3 {
701         Vec3::new(self.w, self.z, self.x)
702     }
703 
704     #[inline]
705     #[must_use]
with_wzx(self, rhs: Vec3) -> Self706     fn with_wzx(self, rhs: Vec3) -> Self {
707         Self::new(rhs.z, self.y, rhs.y, rhs.x)
708     }
709 
710     #[inline]
711     #[must_use]
wzy(self) -> Vec3712     fn wzy(self) -> Vec3 {
713         Vec3::new(self.w, self.z, self.y)
714     }
715 
716     #[inline]
717     #[must_use]
with_wzy(self, rhs: Vec3) -> Self718     fn with_wzy(self, rhs: Vec3) -> Self {
719         Self::new(self.x, rhs.z, rhs.y, rhs.x)
720     }
721 
722     #[inline]
723     #[must_use]
wzz(self) -> Vec3724     fn wzz(self) -> Vec3 {
725         Vec3::new(self.w, self.z, self.z)
726     }
727 
728     #[inline]
729     #[must_use]
wzw(self) -> Vec3730     fn wzw(self) -> Vec3 {
731         Vec3::new(self.w, self.z, self.w)
732     }
733 
734     #[inline]
735     #[must_use]
wwx(self) -> Vec3736     fn wwx(self) -> Vec3 {
737         Vec3::new(self.w, self.w, self.x)
738     }
739 
740     #[inline]
741     #[must_use]
wwy(self) -> Vec3742     fn wwy(self) -> Vec3 {
743         Vec3::new(self.w, self.w, self.y)
744     }
745 
746     #[inline]
747     #[must_use]
wwz(self) -> Vec3748     fn wwz(self) -> Vec3 {
749         Vec3::new(self.w, self.w, self.z)
750     }
751 
752     #[inline]
753     #[must_use]
www(self) -> Vec3754     fn www(self) -> Vec3 {
755         Vec3::new(self.w, self.w, self.w)
756     }
757 
758     #[inline]
759     #[must_use]
xxxx(self) -> Vec4760     fn xxxx(self) -> Vec4 {
761         Vec4(simd_swizzle!(self.0, [0, 0, 0, 0]))
762     }
763 
764     #[inline]
765     #[must_use]
xxxy(self) -> Vec4766     fn xxxy(self) -> Vec4 {
767         Vec4(simd_swizzle!(self.0, [0, 0, 0, 1]))
768     }
769 
770     #[inline]
771     #[must_use]
xxxz(self) -> Vec4772     fn xxxz(self) -> Vec4 {
773         Vec4(simd_swizzle!(self.0, [0, 0, 0, 2]))
774     }
775 
776     #[inline]
777     #[must_use]
xxxw(self) -> Vec4778     fn xxxw(self) -> Vec4 {
779         Vec4(simd_swizzle!(self.0, [0, 0, 0, 3]))
780     }
781 
782     #[inline]
783     #[must_use]
xxyx(self) -> Vec4784     fn xxyx(self) -> Vec4 {
785         Vec4(simd_swizzle!(self.0, [0, 0, 1, 0]))
786     }
787 
788     #[inline]
789     #[must_use]
xxyy(self) -> Vec4790     fn xxyy(self) -> Vec4 {
791         Vec4(simd_swizzle!(self.0, [0, 0, 1, 1]))
792     }
793 
794     #[inline]
795     #[must_use]
xxyz(self) -> Vec4796     fn xxyz(self) -> Vec4 {
797         Vec4(simd_swizzle!(self.0, [0, 0, 1, 2]))
798     }
799 
800     #[inline]
801     #[must_use]
xxyw(self) -> Vec4802     fn xxyw(self) -> Vec4 {
803         Vec4(simd_swizzle!(self.0, [0, 0, 1, 3]))
804     }
805 
806     #[inline]
807     #[must_use]
xxzx(self) -> Vec4808     fn xxzx(self) -> Vec4 {
809         Vec4(simd_swizzle!(self.0, [0, 0, 2, 0]))
810     }
811 
812     #[inline]
813     #[must_use]
xxzy(self) -> Vec4814     fn xxzy(self) -> Vec4 {
815         Vec4(simd_swizzle!(self.0, [0, 0, 2, 1]))
816     }
817 
818     #[inline]
819     #[must_use]
xxzz(self) -> Vec4820     fn xxzz(self) -> Vec4 {
821         Vec4(simd_swizzle!(self.0, [0, 0, 2, 2]))
822     }
823 
824     #[inline]
825     #[must_use]
xxzw(self) -> Vec4826     fn xxzw(self) -> Vec4 {
827         Vec4(simd_swizzle!(self.0, [0, 0, 2, 3]))
828     }
829 
830     #[inline]
831     #[must_use]
xxwx(self) -> Vec4832     fn xxwx(self) -> Vec4 {
833         Vec4(simd_swizzle!(self.0, [0, 0, 3, 0]))
834     }
835 
836     #[inline]
837     #[must_use]
xxwy(self) -> Vec4838     fn xxwy(self) -> Vec4 {
839         Vec4(simd_swizzle!(self.0, [0, 0, 3, 1]))
840     }
841 
842     #[inline]
843     #[must_use]
xxwz(self) -> Vec4844     fn xxwz(self) -> Vec4 {
845         Vec4(simd_swizzle!(self.0, [0, 0, 3, 2]))
846     }
847 
848     #[inline]
849     #[must_use]
xxww(self) -> Vec4850     fn xxww(self) -> Vec4 {
851         Vec4(simd_swizzle!(self.0, [0, 0, 3, 3]))
852     }
853 
854     #[inline]
855     #[must_use]
xyxx(self) -> Vec4856     fn xyxx(self) -> Vec4 {
857         Vec4(simd_swizzle!(self.0, [0, 1, 0, 0]))
858     }
859 
860     #[inline]
861     #[must_use]
xyxy(self) -> Vec4862     fn xyxy(self) -> Vec4 {
863         Vec4(simd_swizzle!(self.0, [0, 1, 0, 1]))
864     }
865 
866     #[inline]
867     #[must_use]
xyxz(self) -> Vec4868     fn xyxz(self) -> Vec4 {
869         Vec4(simd_swizzle!(self.0, [0, 1, 0, 2]))
870     }
871 
872     #[inline]
873     #[must_use]
xyxw(self) -> Vec4874     fn xyxw(self) -> Vec4 {
875         Vec4(simd_swizzle!(self.0, [0, 1, 0, 3]))
876     }
877 
878     #[inline]
879     #[must_use]
xyyx(self) -> Vec4880     fn xyyx(self) -> Vec4 {
881         Vec4(simd_swizzle!(self.0, [0, 1, 1, 0]))
882     }
883 
884     #[inline]
885     #[must_use]
xyyy(self) -> Vec4886     fn xyyy(self) -> Vec4 {
887         Vec4(simd_swizzle!(self.0, [0, 1, 1, 1]))
888     }
889 
890     #[inline]
891     #[must_use]
xyyz(self) -> Vec4892     fn xyyz(self) -> Vec4 {
893         Vec4(simd_swizzle!(self.0, [0, 1, 1, 2]))
894     }
895 
896     #[inline]
897     #[must_use]
xyyw(self) -> Vec4898     fn xyyw(self) -> Vec4 {
899         Vec4(simd_swizzle!(self.0, [0, 1, 1, 3]))
900     }
901 
902     #[inline]
903     #[must_use]
xyzx(self) -> Vec4904     fn xyzx(self) -> Vec4 {
905         Vec4(simd_swizzle!(self.0, [0, 1, 2, 0]))
906     }
907 
908     #[inline]
909     #[must_use]
xyzy(self) -> Vec4910     fn xyzy(self) -> Vec4 {
911         Vec4(simd_swizzle!(self.0, [0, 1, 2, 1]))
912     }
913 
914     #[inline]
915     #[must_use]
xyzz(self) -> Vec4916     fn xyzz(self) -> Vec4 {
917         Vec4(simd_swizzle!(self.0, [0, 1, 2, 2]))
918     }
919 
920     #[inline]
921     #[must_use]
xywx(self) -> Vec4922     fn xywx(self) -> Vec4 {
923         Vec4(simd_swizzle!(self.0, [0, 1, 3, 0]))
924     }
925 
926     #[inline]
927     #[must_use]
xywy(self) -> Vec4928     fn xywy(self) -> Vec4 {
929         Vec4(simd_swizzle!(self.0, [0, 1, 3, 1]))
930     }
931 
932     #[inline]
933     #[must_use]
xywz(self) -> Vec4934     fn xywz(self) -> Vec4 {
935         Vec4(simd_swizzle!(self.0, [0, 1, 3, 2]))
936     }
937 
938     #[inline]
939     #[must_use]
xyww(self) -> Vec4940     fn xyww(self) -> Vec4 {
941         Vec4(simd_swizzle!(self.0, [0, 1, 3, 3]))
942     }
943 
944     #[inline]
945     #[must_use]
xzxx(self) -> Vec4946     fn xzxx(self) -> Vec4 {
947         Vec4(simd_swizzle!(self.0, [0, 2, 0, 0]))
948     }
949 
950     #[inline]
951     #[must_use]
xzxy(self) -> Vec4952     fn xzxy(self) -> Vec4 {
953         Vec4(simd_swizzle!(self.0, [0, 2, 0, 1]))
954     }
955 
956     #[inline]
957     #[must_use]
xzxz(self) -> Vec4958     fn xzxz(self) -> Vec4 {
959         Vec4(simd_swizzle!(self.0, [0, 2, 0, 2]))
960     }
961 
962     #[inline]
963     #[must_use]
xzxw(self) -> Vec4964     fn xzxw(self) -> Vec4 {
965         Vec4(simd_swizzle!(self.0, [0, 2, 0, 3]))
966     }
967 
968     #[inline]
969     #[must_use]
xzyx(self) -> Vec4970     fn xzyx(self) -> Vec4 {
971         Vec4(simd_swizzle!(self.0, [0, 2, 1, 0]))
972     }
973 
974     #[inline]
975     #[must_use]
xzyy(self) -> Vec4976     fn xzyy(self) -> Vec4 {
977         Vec4(simd_swizzle!(self.0, [0, 2, 1, 1]))
978     }
979 
980     #[inline]
981     #[must_use]
xzyz(self) -> Vec4982     fn xzyz(self) -> Vec4 {
983         Vec4(simd_swizzle!(self.0, [0, 2, 1, 2]))
984     }
985 
986     #[inline]
987     #[must_use]
xzyw(self) -> Vec4988     fn xzyw(self) -> Vec4 {
989         Vec4(simd_swizzle!(self.0, [0, 2, 1, 3]))
990     }
991 
992     #[inline]
993     #[must_use]
xzzx(self) -> Vec4994     fn xzzx(self) -> Vec4 {
995         Vec4(simd_swizzle!(self.0, [0, 2, 2, 0]))
996     }
997 
998     #[inline]
999     #[must_use]
xzzy(self) -> Vec41000     fn xzzy(self) -> Vec4 {
1001         Vec4(simd_swizzle!(self.0, [0, 2, 2, 1]))
1002     }
1003 
1004     #[inline]
1005     #[must_use]
xzzz(self) -> Vec41006     fn xzzz(self) -> Vec4 {
1007         Vec4(simd_swizzle!(self.0, [0, 2, 2, 2]))
1008     }
1009 
1010     #[inline]
1011     #[must_use]
xzzw(self) -> Vec41012     fn xzzw(self) -> Vec4 {
1013         Vec4(simd_swizzle!(self.0, [0, 2, 2, 3]))
1014     }
1015 
1016     #[inline]
1017     #[must_use]
xzwx(self) -> Vec41018     fn xzwx(self) -> Vec4 {
1019         Vec4(simd_swizzle!(self.0, [0, 2, 3, 0]))
1020     }
1021 
1022     #[inline]
1023     #[must_use]
xzwy(self) -> Vec41024     fn xzwy(self) -> Vec4 {
1025         Vec4(simd_swizzle!(self.0, [0, 2, 3, 1]))
1026     }
1027 
1028     #[inline]
1029     #[must_use]
xzwz(self) -> Vec41030     fn xzwz(self) -> Vec4 {
1031         Vec4(simd_swizzle!(self.0, [0, 2, 3, 2]))
1032     }
1033 
1034     #[inline]
1035     #[must_use]
xzww(self) -> Vec41036     fn xzww(self) -> Vec4 {
1037         Vec4(simd_swizzle!(self.0, [0, 2, 3, 3]))
1038     }
1039 
1040     #[inline]
1041     #[must_use]
xwxx(self) -> Vec41042     fn xwxx(self) -> Vec4 {
1043         Vec4(simd_swizzle!(self.0, [0, 3, 0, 0]))
1044     }
1045 
1046     #[inline]
1047     #[must_use]
xwxy(self) -> Vec41048     fn xwxy(self) -> Vec4 {
1049         Vec4(simd_swizzle!(self.0, [0, 3, 0, 1]))
1050     }
1051 
1052     #[inline]
1053     #[must_use]
xwxz(self) -> Vec41054     fn xwxz(self) -> Vec4 {
1055         Vec4(simd_swizzle!(self.0, [0, 3, 0, 2]))
1056     }
1057 
1058     #[inline]
1059     #[must_use]
xwxw(self) -> Vec41060     fn xwxw(self) -> Vec4 {
1061         Vec4(simd_swizzle!(self.0, [0, 3, 0, 3]))
1062     }
1063 
1064     #[inline]
1065     #[must_use]
xwyx(self) -> Vec41066     fn xwyx(self) -> Vec4 {
1067         Vec4(simd_swizzle!(self.0, [0, 3, 1, 0]))
1068     }
1069 
1070     #[inline]
1071     #[must_use]
xwyy(self) -> Vec41072     fn xwyy(self) -> Vec4 {
1073         Vec4(simd_swizzle!(self.0, [0, 3, 1, 1]))
1074     }
1075 
1076     #[inline]
1077     #[must_use]
xwyz(self) -> Vec41078     fn xwyz(self) -> Vec4 {
1079         Vec4(simd_swizzle!(self.0, [0, 3, 1, 2]))
1080     }
1081 
1082     #[inline]
1083     #[must_use]
xwyw(self) -> Vec41084     fn xwyw(self) -> Vec4 {
1085         Vec4(simd_swizzle!(self.0, [0, 3, 1, 3]))
1086     }
1087 
1088     #[inline]
1089     #[must_use]
xwzx(self) -> Vec41090     fn xwzx(self) -> Vec4 {
1091         Vec4(simd_swizzle!(self.0, [0, 3, 2, 0]))
1092     }
1093 
1094     #[inline]
1095     #[must_use]
xwzy(self) -> Vec41096     fn xwzy(self) -> Vec4 {
1097         Vec4(simd_swizzle!(self.0, [0, 3, 2, 1]))
1098     }
1099 
1100     #[inline]
1101     #[must_use]
xwzz(self) -> Vec41102     fn xwzz(self) -> Vec4 {
1103         Vec4(simd_swizzle!(self.0, [0, 3, 2, 2]))
1104     }
1105 
1106     #[inline]
1107     #[must_use]
xwzw(self) -> Vec41108     fn xwzw(self) -> Vec4 {
1109         Vec4(simd_swizzle!(self.0, [0, 3, 2, 3]))
1110     }
1111 
1112     #[inline]
1113     #[must_use]
xwwx(self) -> Vec41114     fn xwwx(self) -> Vec4 {
1115         Vec4(simd_swizzle!(self.0, [0, 3, 3, 0]))
1116     }
1117 
1118     #[inline]
1119     #[must_use]
xwwy(self) -> Vec41120     fn xwwy(self) -> Vec4 {
1121         Vec4(simd_swizzle!(self.0, [0, 3, 3, 1]))
1122     }
1123 
1124     #[inline]
1125     #[must_use]
xwwz(self) -> Vec41126     fn xwwz(self) -> Vec4 {
1127         Vec4(simd_swizzle!(self.0, [0, 3, 3, 2]))
1128     }
1129 
1130     #[inline]
1131     #[must_use]
xwww(self) -> Vec41132     fn xwww(self) -> Vec4 {
1133         Vec4(simd_swizzle!(self.0, [0, 3, 3, 3]))
1134     }
1135 
1136     #[inline]
1137     #[must_use]
yxxx(self) -> Vec41138     fn yxxx(self) -> Vec4 {
1139         Vec4(simd_swizzle!(self.0, [1, 0, 0, 0]))
1140     }
1141 
1142     #[inline]
1143     #[must_use]
yxxy(self) -> Vec41144     fn yxxy(self) -> Vec4 {
1145         Vec4(simd_swizzle!(self.0, [1, 0, 0, 1]))
1146     }
1147 
1148     #[inline]
1149     #[must_use]
yxxz(self) -> Vec41150     fn yxxz(self) -> Vec4 {
1151         Vec4(simd_swizzle!(self.0, [1, 0, 0, 2]))
1152     }
1153 
1154     #[inline]
1155     #[must_use]
yxxw(self) -> Vec41156     fn yxxw(self) -> Vec4 {
1157         Vec4(simd_swizzle!(self.0, [1, 0, 0, 3]))
1158     }
1159 
1160     #[inline]
1161     #[must_use]
yxyx(self) -> Vec41162     fn yxyx(self) -> Vec4 {
1163         Vec4(simd_swizzle!(self.0, [1, 0, 1, 0]))
1164     }
1165 
1166     #[inline]
1167     #[must_use]
yxyy(self) -> Vec41168     fn yxyy(self) -> Vec4 {
1169         Vec4(simd_swizzle!(self.0, [1, 0, 1, 1]))
1170     }
1171 
1172     #[inline]
1173     #[must_use]
yxyz(self) -> Vec41174     fn yxyz(self) -> Vec4 {
1175         Vec4(simd_swizzle!(self.0, [1, 0, 1, 2]))
1176     }
1177 
1178     #[inline]
1179     #[must_use]
yxyw(self) -> Vec41180     fn yxyw(self) -> Vec4 {
1181         Vec4(simd_swizzle!(self.0, [1, 0, 1, 3]))
1182     }
1183 
1184     #[inline]
1185     #[must_use]
yxzx(self) -> Vec41186     fn yxzx(self) -> Vec4 {
1187         Vec4(simd_swizzle!(self.0, [1, 0, 2, 0]))
1188     }
1189 
1190     #[inline]
1191     #[must_use]
yxzy(self) -> Vec41192     fn yxzy(self) -> Vec4 {
1193         Vec4(simd_swizzle!(self.0, [1, 0, 2, 1]))
1194     }
1195 
1196     #[inline]
1197     #[must_use]
yxzz(self) -> Vec41198     fn yxzz(self) -> Vec4 {
1199         Vec4(simd_swizzle!(self.0, [1, 0, 2, 2]))
1200     }
1201 
1202     #[inline]
1203     #[must_use]
yxzw(self) -> Vec41204     fn yxzw(self) -> Vec4 {
1205         Vec4(simd_swizzle!(self.0, [1, 0, 2, 3]))
1206     }
1207 
1208     #[inline]
1209     #[must_use]
yxwx(self) -> Vec41210     fn yxwx(self) -> Vec4 {
1211         Vec4(simd_swizzle!(self.0, [1, 0, 3, 0]))
1212     }
1213 
1214     #[inline]
1215     #[must_use]
yxwy(self) -> Vec41216     fn yxwy(self) -> Vec4 {
1217         Vec4(simd_swizzle!(self.0, [1, 0, 3, 1]))
1218     }
1219 
1220     #[inline]
1221     #[must_use]
yxwz(self) -> Vec41222     fn yxwz(self) -> Vec4 {
1223         Vec4(simd_swizzle!(self.0, [1, 0, 3, 2]))
1224     }
1225 
1226     #[inline]
1227     #[must_use]
yxww(self) -> Vec41228     fn yxww(self) -> Vec4 {
1229         Vec4(simd_swizzle!(self.0, [1, 0, 3, 3]))
1230     }
1231 
1232     #[inline]
1233     #[must_use]
yyxx(self) -> Vec41234     fn yyxx(self) -> Vec4 {
1235         Vec4(simd_swizzle!(self.0, [1, 1, 0, 0]))
1236     }
1237 
1238     #[inline]
1239     #[must_use]
yyxy(self) -> Vec41240     fn yyxy(self) -> Vec4 {
1241         Vec4(simd_swizzle!(self.0, [1, 1, 0, 1]))
1242     }
1243 
1244     #[inline]
1245     #[must_use]
yyxz(self) -> Vec41246     fn yyxz(self) -> Vec4 {
1247         Vec4(simd_swizzle!(self.0, [1, 1, 0, 2]))
1248     }
1249 
1250     #[inline]
1251     #[must_use]
yyxw(self) -> Vec41252     fn yyxw(self) -> Vec4 {
1253         Vec4(simd_swizzle!(self.0, [1, 1, 0, 3]))
1254     }
1255 
1256     #[inline]
1257     #[must_use]
yyyx(self) -> Vec41258     fn yyyx(self) -> Vec4 {
1259         Vec4(simd_swizzle!(self.0, [1, 1, 1, 0]))
1260     }
1261 
1262     #[inline]
1263     #[must_use]
yyyy(self) -> Vec41264     fn yyyy(self) -> Vec4 {
1265         Vec4(simd_swizzle!(self.0, [1, 1, 1, 1]))
1266     }
1267 
1268     #[inline]
1269     #[must_use]
yyyz(self) -> Vec41270     fn yyyz(self) -> Vec4 {
1271         Vec4(simd_swizzle!(self.0, [1, 1, 1, 2]))
1272     }
1273 
1274     #[inline]
1275     #[must_use]
yyyw(self) -> Vec41276     fn yyyw(self) -> Vec4 {
1277         Vec4(simd_swizzle!(self.0, [1, 1, 1, 3]))
1278     }
1279 
1280     #[inline]
1281     #[must_use]
yyzx(self) -> Vec41282     fn yyzx(self) -> Vec4 {
1283         Vec4(simd_swizzle!(self.0, [1, 1, 2, 0]))
1284     }
1285 
1286     #[inline]
1287     #[must_use]
yyzy(self) -> Vec41288     fn yyzy(self) -> Vec4 {
1289         Vec4(simd_swizzle!(self.0, [1, 1, 2, 1]))
1290     }
1291 
1292     #[inline]
1293     #[must_use]
yyzz(self) -> Vec41294     fn yyzz(self) -> Vec4 {
1295         Vec4(simd_swizzle!(self.0, [1, 1, 2, 2]))
1296     }
1297 
1298     #[inline]
1299     #[must_use]
yyzw(self) -> Vec41300     fn yyzw(self) -> Vec4 {
1301         Vec4(simd_swizzle!(self.0, [1, 1, 2, 3]))
1302     }
1303 
1304     #[inline]
1305     #[must_use]
yywx(self) -> Vec41306     fn yywx(self) -> Vec4 {
1307         Vec4(simd_swizzle!(self.0, [1, 1, 3, 0]))
1308     }
1309 
1310     #[inline]
1311     #[must_use]
yywy(self) -> Vec41312     fn yywy(self) -> Vec4 {
1313         Vec4(simd_swizzle!(self.0, [1, 1, 3, 1]))
1314     }
1315 
1316     #[inline]
1317     #[must_use]
yywz(self) -> Vec41318     fn yywz(self) -> Vec4 {
1319         Vec4(simd_swizzle!(self.0, [1, 1, 3, 2]))
1320     }
1321 
1322     #[inline]
1323     #[must_use]
yyww(self) -> Vec41324     fn yyww(self) -> Vec4 {
1325         Vec4(simd_swizzle!(self.0, [1, 1, 3, 3]))
1326     }
1327 
1328     #[inline]
1329     #[must_use]
yzxx(self) -> Vec41330     fn yzxx(self) -> Vec4 {
1331         Vec4(simd_swizzle!(self.0, [1, 2, 0, 0]))
1332     }
1333 
1334     #[inline]
1335     #[must_use]
yzxy(self) -> Vec41336     fn yzxy(self) -> Vec4 {
1337         Vec4(simd_swizzle!(self.0, [1, 2, 0, 1]))
1338     }
1339 
1340     #[inline]
1341     #[must_use]
yzxz(self) -> Vec41342     fn yzxz(self) -> Vec4 {
1343         Vec4(simd_swizzle!(self.0, [1, 2, 0, 2]))
1344     }
1345 
1346     #[inline]
1347     #[must_use]
yzxw(self) -> Vec41348     fn yzxw(self) -> Vec4 {
1349         Vec4(simd_swizzle!(self.0, [1, 2, 0, 3]))
1350     }
1351 
1352     #[inline]
1353     #[must_use]
yzyx(self) -> Vec41354     fn yzyx(self) -> Vec4 {
1355         Vec4(simd_swizzle!(self.0, [1, 2, 1, 0]))
1356     }
1357 
1358     #[inline]
1359     #[must_use]
yzyy(self) -> Vec41360     fn yzyy(self) -> Vec4 {
1361         Vec4(simd_swizzle!(self.0, [1, 2, 1, 1]))
1362     }
1363 
1364     #[inline]
1365     #[must_use]
yzyz(self) -> Vec41366     fn yzyz(self) -> Vec4 {
1367         Vec4(simd_swizzle!(self.0, [1, 2, 1, 2]))
1368     }
1369 
1370     #[inline]
1371     #[must_use]
yzyw(self) -> Vec41372     fn yzyw(self) -> Vec4 {
1373         Vec4(simd_swizzle!(self.0, [1, 2, 1, 3]))
1374     }
1375 
1376     #[inline]
1377     #[must_use]
yzzx(self) -> Vec41378     fn yzzx(self) -> Vec4 {
1379         Vec4(simd_swizzle!(self.0, [1, 2, 2, 0]))
1380     }
1381 
1382     #[inline]
1383     #[must_use]
yzzy(self) -> Vec41384     fn yzzy(self) -> Vec4 {
1385         Vec4(simd_swizzle!(self.0, [1, 2, 2, 1]))
1386     }
1387 
1388     #[inline]
1389     #[must_use]
yzzz(self) -> Vec41390     fn yzzz(self) -> Vec4 {
1391         Vec4(simd_swizzle!(self.0, [1, 2, 2, 2]))
1392     }
1393 
1394     #[inline]
1395     #[must_use]
yzzw(self) -> Vec41396     fn yzzw(self) -> Vec4 {
1397         Vec4(simd_swizzle!(self.0, [1, 2, 2, 3]))
1398     }
1399 
1400     #[inline]
1401     #[must_use]
yzwx(self) -> Vec41402     fn yzwx(self) -> Vec4 {
1403         Vec4(simd_swizzle!(self.0, [1, 2, 3, 0]))
1404     }
1405 
1406     #[inline]
1407     #[must_use]
yzwy(self) -> Vec41408     fn yzwy(self) -> Vec4 {
1409         Vec4(simd_swizzle!(self.0, [1, 2, 3, 1]))
1410     }
1411 
1412     #[inline]
1413     #[must_use]
yzwz(self) -> Vec41414     fn yzwz(self) -> Vec4 {
1415         Vec4(simd_swizzle!(self.0, [1, 2, 3, 2]))
1416     }
1417 
1418     #[inline]
1419     #[must_use]
yzww(self) -> Vec41420     fn yzww(self) -> Vec4 {
1421         Vec4(simd_swizzle!(self.0, [1, 2, 3, 3]))
1422     }
1423 
1424     #[inline]
1425     #[must_use]
ywxx(self) -> Vec41426     fn ywxx(self) -> Vec4 {
1427         Vec4(simd_swizzle!(self.0, [1, 3, 0, 0]))
1428     }
1429 
1430     #[inline]
1431     #[must_use]
ywxy(self) -> Vec41432     fn ywxy(self) -> Vec4 {
1433         Vec4(simd_swizzle!(self.0, [1, 3, 0, 1]))
1434     }
1435 
1436     #[inline]
1437     #[must_use]
ywxz(self) -> Vec41438     fn ywxz(self) -> Vec4 {
1439         Vec4(simd_swizzle!(self.0, [1, 3, 0, 2]))
1440     }
1441 
1442     #[inline]
1443     #[must_use]
ywxw(self) -> Vec41444     fn ywxw(self) -> Vec4 {
1445         Vec4(simd_swizzle!(self.0, [1, 3, 0, 3]))
1446     }
1447 
1448     #[inline]
1449     #[must_use]
ywyx(self) -> Vec41450     fn ywyx(self) -> Vec4 {
1451         Vec4(simd_swizzle!(self.0, [1, 3, 1, 0]))
1452     }
1453 
1454     #[inline]
1455     #[must_use]
ywyy(self) -> Vec41456     fn ywyy(self) -> Vec4 {
1457         Vec4(simd_swizzle!(self.0, [1, 3, 1, 1]))
1458     }
1459 
1460     #[inline]
1461     #[must_use]
ywyz(self) -> Vec41462     fn ywyz(self) -> Vec4 {
1463         Vec4(simd_swizzle!(self.0, [1, 3, 1, 2]))
1464     }
1465 
1466     #[inline]
1467     #[must_use]
ywyw(self) -> Vec41468     fn ywyw(self) -> Vec4 {
1469         Vec4(simd_swizzle!(self.0, [1, 3, 1, 3]))
1470     }
1471 
1472     #[inline]
1473     #[must_use]
ywzx(self) -> Vec41474     fn ywzx(self) -> Vec4 {
1475         Vec4(simd_swizzle!(self.0, [1, 3, 2, 0]))
1476     }
1477 
1478     #[inline]
1479     #[must_use]
ywzy(self) -> Vec41480     fn ywzy(self) -> Vec4 {
1481         Vec4(simd_swizzle!(self.0, [1, 3, 2, 1]))
1482     }
1483 
1484     #[inline]
1485     #[must_use]
ywzz(self) -> Vec41486     fn ywzz(self) -> Vec4 {
1487         Vec4(simd_swizzle!(self.0, [1, 3, 2, 2]))
1488     }
1489 
1490     #[inline]
1491     #[must_use]
ywzw(self) -> Vec41492     fn ywzw(self) -> Vec4 {
1493         Vec4(simd_swizzle!(self.0, [1, 3, 2, 3]))
1494     }
1495 
1496     #[inline]
1497     #[must_use]
ywwx(self) -> Vec41498     fn ywwx(self) -> Vec4 {
1499         Vec4(simd_swizzle!(self.0, [1, 3, 3, 0]))
1500     }
1501 
1502     #[inline]
1503     #[must_use]
ywwy(self) -> Vec41504     fn ywwy(self) -> Vec4 {
1505         Vec4(simd_swizzle!(self.0, [1, 3, 3, 1]))
1506     }
1507 
1508     #[inline]
1509     #[must_use]
ywwz(self) -> Vec41510     fn ywwz(self) -> Vec4 {
1511         Vec4(simd_swizzle!(self.0, [1, 3, 3, 2]))
1512     }
1513 
1514     #[inline]
1515     #[must_use]
ywww(self) -> Vec41516     fn ywww(self) -> Vec4 {
1517         Vec4(simd_swizzle!(self.0, [1, 3, 3, 3]))
1518     }
1519 
1520     #[inline]
1521     #[must_use]
zxxx(self) -> Vec41522     fn zxxx(self) -> Vec4 {
1523         Vec4(simd_swizzle!(self.0, [2, 0, 0, 0]))
1524     }
1525 
1526     #[inline]
1527     #[must_use]
zxxy(self) -> Vec41528     fn zxxy(self) -> Vec4 {
1529         Vec4(simd_swizzle!(self.0, [2, 0, 0, 1]))
1530     }
1531 
1532     #[inline]
1533     #[must_use]
zxxz(self) -> Vec41534     fn zxxz(self) -> Vec4 {
1535         Vec4(simd_swizzle!(self.0, [2, 0, 0, 2]))
1536     }
1537 
1538     #[inline]
1539     #[must_use]
zxxw(self) -> Vec41540     fn zxxw(self) -> Vec4 {
1541         Vec4(simd_swizzle!(self.0, [2, 0, 0, 3]))
1542     }
1543 
1544     #[inline]
1545     #[must_use]
zxyx(self) -> Vec41546     fn zxyx(self) -> Vec4 {
1547         Vec4(simd_swizzle!(self.0, [2, 0, 1, 0]))
1548     }
1549 
1550     #[inline]
1551     #[must_use]
zxyy(self) -> Vec41552     fn zxyy(self) -> Vec4 {
1553         Vec4(simd_swizzle!(self.0, [2, 0, 1, 1]))
1554     }
1555 
1556     #[inline]
1557     #[must_use]
zxyz(self) -> Vec41558     fn zxyz(self) -> Vec4 {
1559         Vec4(simd_swizzle!(self.0, [2, 0, 1, 2]))
1560     }
1561 
1562     #[inline]
1563     #[must_use]
zxyw(self) -> Vec41564     fn zxyw(self) -> Vec4 {
1565         Vec4(simd_swizzle!(self.0, [2, 0, 1, 3]))
1566     }
1567 
1568     #[inline]
1569     #[must_use]
zxzx(self) -> Vec41570     fn zxzx(self) -> Vec4 {
1571         Vec4(simd_swizzle!(self.0, [2, 0, 2, 0]))
1572     }
1573 
1574     #[inline]
1575     #[must_use]
zxzy(self) -> Vec41576     fn zxzy(self) -> Vec4 {
1577         Vec4(simd_swizzle!(self.0, [2, 0, 2, 1]))
1578     }
1579 
1580     #[inline]
1581     #[must_use]
zxzz(self) -> Vec41582     fn zxzz(self) -> Vec4 {
1583         Vec4(simd_swizzle!(self.0, [2, 0, 2, 2]))
1584     }
1585 
1586     #[inline]
1587     #[must_use]
zxzw(self) -> Vec41588     fn zxzw(self) -> Vec4 {
1589         Vec4(simd_swizzle!(self.0, [2, 0, 2, 3]))
1590     }
1591 
1592     #[inline]
1593     #[must_use]
zxwx(self) -> Vec41594     fn zxwx(self) -> Vec4 {
1595         Vec4(simd_swizzle!(self.0, [2, 0, 3, 0]))
1596     }
1597 
1598     #[inline]
1599     #[must_use]
zxwy(self) -> Vec41600     fn zxwy(self) -> Vec4 {
1601         Vec4(simd_swizzle!(self.0, [2, 0, 3, 1]))
1602     }
1603 
1604     #[inline]
1605     #[must_use]
zxwz(self) -> Vec41606     fn zxwz(self) -> Vec4 {
1607         Vec4(simd_swizzle!(self.0, [2, 0, 3, 2]))
1608     }
1609 
1610     #[inline]
1611     #[must_use]
zxww(self) -> Vec41612     fn zxww(self) -> Vec4 {
1613         Vec4(simd_swizzle!(self.0, [2, 0, 3, 3]))
1614     }
1615 
1616     #[inline]
1617     #[must_use]
zyxx(self) -> Vec41618     fn zyxx(self) -> Vec4 {
1619         Vec4(simd_swizzle!(self.0, [2, 1, 0, 0]))
1620     }
1621 
1622     #[inline]
1623     #[must_use]
zyxy(self) -> Vec41624     fn zyxy(self) -> Vec4 {
1625         Vec4(simd_swizzle!(self.0, [2, 1, 0, 1]))
1626     }
1627 
1628     #[inline]
1629     #[must_use]
zyxz(self) -> Vec41630     fn zyxz(self) -> Vec4 {
1631         Vec4(simd_swizzle!(self.0, [2, 1, 0, 2]))
1632     }
1633 
1634     #[inline]
1635     #[must_use]
zyxw(self) -> Vec41636     fn zyxw(self) -> Vec4 {
1637         Vec4(simd_swizzle!(self.0, [2, 1, 0, 3]))
1638     }
1639 
1640     #[inline]
1641     #[must_use]
zyyx(self) -> Vec41642     fn zyyx(self) -> Vec4 {
1643         Vec4(simd_swizzle!(self.0, [2, 1, 1, 0]))
1644     }
1645 
1646     #[inline]
1647     #[must_use]
zyyy(self) -> Vec41648     fn zyyy(self) -> Vec4 {
1649         Vec4(simd_swizzle!(self.0, [2, 1, 1, 1]))
1650     }
1651 
1652     #[inline]
1653     #[must_use]
zyyz(self) -> Vec41654     fn zyyz(self) -> Vec4 {
1655         Vec4(simd_swizzle!(self.0, [2, 1, 1, 2]))
1656     }
1657 
1658     #[inline]
1659     #[must_use]
zyyw(self) -> Vec41660     fn zyyw(self) -> Vec4 {
1661         Vec4(simd_swizzle!(self.0, [2, 1, 1, 3]))
1662     }
1663 
1664     #[inline]
1665     #[must_use]
zyzx(self) -> Vec41666     fn zyzx(self) -> Vec4 {
1667         Vec4(simd_swizzle!(self.0, [2, 1, 2, 0]))
1668     }
1669 
1670     #[inline]
1671     #[must_use]
zyzy(self) -> Vec41672     fn zyzy(self) -> Vec4 {
1673         Vec4(simd_swizzle!(self.0, [2, 1, 2, 1]))
1674     }
1675 
1676     #[inline]
1677     #[must_use]
zyzz(self) -> Vec41678     fn zyzz(self) -> Vec4 {
1679         Vec4(simd_swizzle!(self.0, [2, 1, 2, 2]))
1680     }
1681 
1682     #[inline]
1683     #[must_use]
zyzw(self) -> Vec41684     fn zyzw(self) -> Vec4 {
1685         Vec4(simd_swizzle!(self.0, [2, 1, 2, 3]))
1686     }
1687 
1688     #[inline]
1689     #[must_use]
zywx(self) -> Vec41690     fn zywx(self) -> Vec4 {
1691         Vec4(simd_swizzle!(self.0, [2, 1, 3, 0]))
1692     }
1693 
1694     #[inline]
1695     #[must_use]
zywy(self) -> Vec41696     fn zywy(self) -> Vec4 {
1697         Vec4(simd_swizzle!(self.0, [2, 1, 3, 1]))
1698     }
1699 
1700     #[inline]
1701     #[must_use]
zywz(self) -> Vec41702     fn zywz(self) -> Vec4 {
1703         Vec4(simd_swizzle!(self.0, [2, 1, 3, 2]))
1704     }
1705 
1706     #[inline]
1707     #[must_use]
zyww(self) -> Vec41708     fn zyww(self) -> Vec4 {
1709         Vec4(simd_swizzle!(self.0, [2, 1, 3, 3]))
1710     }
1711 
1712     #[inline]
1713     #[must_use]
zzxx(self) -> Vec41714     fn zzxx(self) -> Vec4 {
1715         Vec4(simd_swizzle!(self.0, [2, 2, 0, 0]))
1716     }
1717 
1718     #[inline]
1719     #[must_use]
zzxy(self) -> Vec41720     fn zzxy(self) -> Vec4 {
1721         Vec4(simd_swizzle!(self.0, [2, 2, 0, 1]))
1722     }
1723 
1724     #[inline]
1725     #[must_use]
zzxz(self) -> Vec41726     fn zzxz(self) -> Vec4 {
1727         Vec4(simd_swizzle!(self.0, [2, 2, 0, 2]))
1728     }
1729 
1730     #[inline]
1731     #[must_use]
zzxw(self) -> Vec41732     fn zzxw(self) -> Vec4 {
1733         Vec4(simd_swizzle!(self.0, [2, 2, 0, 3]))
1734     }
1735 
1736     #[inline]
1737     #[must_use]
zzyx(self) -> Vec41738     fn zzyx(self) -> Vec4 {
1739         Vec4(simd_swizzle!(self.0, [2, 2, 1, 0]))
1740     }
1741 
1742     #[inline]
1743     #[must_use]
zzyy(self) -> Vec41744     fn zzyy(self) -> Vec4 {
1745         Vec4(simd_swizzle!(self.0, [2, 2, 1, 1]))
1746     }
1747 
1748     #[inline]
1749     #[must_use]
zzyz(self) -> Vec41750     fn zzyz(self) -> Vec4 {
1751         Vec4(simd_swizzle!(self.0, [2, 2, 1, 2]))
1752     }
1753 
1754     #[inline]
1755     #[must_use]
zzyw(self) -> Vec41756     fn zzyw(self) -> Vec4 {
1757         Vec4(simd_swizzle!(self.0, [2, 2, 1, 3]))
1758     }
1759 
1760     #[inline]
1761     #[must_use]
zzzx(self) -> Vec41762     fn zzzx(self) -> Vec4 {
1763         Vec4(simd_swizzle!(self.0, [2, 2, 2, 0]))
1764     }
1765 
1766     #[inline]
1767     #[must_use]
zzzy(self) -> Vec41768     fn zzzy(self) -> Vec4 {
1769         Vec4(simd_swizzle!(self.0, [2, 2, 2, 1]))
1770     }
1771 
1772     #[inline]
1773     #[must_use]
zzzz(self) -> Vec41774     fn zzzz(self) -> Vec4 {
1775         Vec4(simd_swizzle!(self.0, [2, 2, 2, 2]))
1776     }
1777 
1778     #[inline]
1779     #[must_use]
zzzw(self) -> Vec41780     fn zzzw(self) -> Vec4 {
1781         Vec4(simd_swizzle!(self.0, [2, 2, 2, 3]))
1782     }
1783 
1784     #[inline]
1785     #[must_use]
zzwx(self) -> Vec41786     fn zzwx(self) -> Vec4 {
1787         Vec4(simd_swizzle!(self.0, [2, 2, 3, 0]))
1788     }
1789 
1790     #[inline]
1791     #[must_use]
zzwy(self) -> Vec41792     fn zzwy(self) -> Vec4 {
1793         Vec4(simd_swizzle!(self.0, [2, 2, 3, 1]))
1794     }
1795 
1796     #[inline]
1797     #[must_use]
zzwz(self) -> Vec41798     fn zzwz(self) -> Vec4 {
1799         Vec4(simd_swizzle!(self.0, [2, 2, 3, 2]))
1800     }
1801 
1802     #[inline]
1803     #[must_use]
zzww(self) -> Vec41804     fn zzww(self) -> Vec4 {
1805         Vec4(simd_swizzle!(self.0, [2, 2, 3, 3]))
1806     }
1807 
1808     #[inline]
1809     #[must_use]
zwxx(self) -> Vec41810     fn zwxx(self) -> Vec4 {
1811         Vec4(simd_swizzle!(self.0, [2, 3, 0, 0]))
1812     }
1813 
1814     #[inline]
1815     #[must_use]
zwxy(self) -> Vec41816     fn zwxy(self) -> Vec4 {
1817         Vec4(simd_swizzle!(self.0, [2, 3, 0, 1]))
1818     }
1819 
1820     #[inline]
1821     #[must_use]
zwxz(self) -> Vec41822     fn zwxz(self) -> Vec4 {
1823         Vec4(simd_swizzle!(self.0, [2, 3, 0, 2]))
1824     }
1825 
1826     #[inline]
1827     #[must_use]
zwxw(self) -> Vec41828     fn zwxw(self) -> Vec4 {
1829         Vec4(simd_swizzle!(self.0, [2, 3, 0, 3]))
1830     }
1831 
1832     #[inline]
1833     #[must_use]
zwyx(self) -> Vec41834     fn zwyx(self) -> Vec4 {
1835         Vec4(simd_swizzle!(self.0, [2, 3, 1, 0]))
1836     }
1837 
1838     #[inline]
1839     #[must_use]
zwyy(self) -> Vec41840     fn zwyy(self) -> Vec4 {
1841         Vec4(simd_swizzle!(self.0, [2, 3, 1, 1]))
1842     }
1843 
1844     #[inline]
1845     #[must_use]
zwyz(self) -> Vec41846     fn zwyz(self) -> Vec4 {
1847         Vec4(simd_swizzle!(self.0, [2, 3, 1, 2]))
1848     }
1849 
1850     #[inline]
1851     #[must_use]
zwyw(self) -> Vec41852     fn zwyw(self) -> Vec4 {
1853         Vec4(simd_swizzle!(self.0, [2, 3, 1, 3]))
1854     }
1855 
1856     #[inline]
1857     #[must_use]
zwzx(self) -> Vec41858     fn zwzx(self) -> Vec4 {
1859         Vec4(simd_swizzle!(self.0, [2, 3, 2, 0]))
1860     }
1861 
1862     #[inline]
1863     #[must_use]
zwzy(self) -> Vec41864     fn zwzy(self) -> Vec4 {
1865         Vec4(simd_swizzle!(self.0, [2, 3, 2, 1]))
1866     }
1867 
1868     #[inline]
1869     #[must_use]
zwzz(self) -> Vec41870     fn zwzz(self) -> Vec4 {
1871         Vec4(simd_swizzle!(self.0, [2, 3, 2, 2]))
1872     }
1873 
1874     #[inline]
1875     #[must_use]
zwzw(self) -> Vec41876     fn zwzw(self) -> Vec4 {
1877         Vec4(simd_swizzle!(self.0, [2, 3, 2, 3]))
1878     }
1879 
1880     #[inline]
1881     #[must_use]
zwwx(self) -> Vec41882     fn zwwx(self) -> Vec4 {
1883         Vec4(simd_swizzle!(self.0, [2, 3, 3, 0]))
1884     }
1885 
1886     #[inline]
1887     #[must_use]
zwwy(self) -> Vec41888     fn zwwy(self) -> Vec4 {
1889         Vec4(simd_swizzle!(self.0, [2, 3, 3, 1]))
1890     }
1891 
1892     #[inline]
1893     #[must_use]
zwwz(self) -> Vec41894     fn zwwz(self) -> Vec4 {
1895         Vec4(simd_swizzle!(self.0, [2, 3, 3, 2]))
1896     }
1897 
1898     #[inline]
1899     #[must_use]
zwww(self) -> Vec41900     fn zwww(self) -> Vec4 {
1901         Vec4(simd_swizzle!(self.0, [2, 3, 3, 3]))
1902     }
1903 
1904     #[inline]
1905     #[must_use]
wxxx(self) -> Vec41906     fn wxxx(self) -> Vec4 {
1907         Vec4(simd_swizzle!(self.0, [3, 0, 0, 0]))
1908     }
1909 
1910     #[inline]
1911     #[must_use]
wxxy(self) -> Vec41912     fn wxxy(self) -> Vec4 {
1913         Vec4(simd_swizzle!(self.0, [3, 0, 0, 1]))
1914     }
1915 
1916     #[inline]
1917     #[must_use]
wxxz(self) -> Vec41918     fn wxxz(self) -> Vec4 {
1919         Vec4(simd_swizzle!(self.0, [3, 0, 0, 2]))
1920     }
1921 
1922     #[inline]
1923     #[must_use]
wxxw(self) -> Vec41924     fn wxxw(self) -> Vec4 {
1925         Vec4(simd_swizzle!(self.0, [3, 0, 0, 3]))
1926     }
1927 
1928     #[inline]
1929     #[must_use]
wxyx(self) -> Vec41930     fn wxyx(self) -> Vec4 {
1931         Vec4(simd_swizzle!(self.0, [3, 0, 1, 0]))
1932     }
1933 
1934     #[inline]
1935     #[must_use]
wxyy(self) -> Vec41936     fn wxyy(self) -> Vec4 {
1937         Vec4(simd_swizzle!(self.0, [3, 0, 1, 1]))
1938     }
1939 
1940     #[inline]
1941     #[must_use]
wxyz(self) -> Vec41942     fn wxyz(self) -> Vec4 {
1943         Vec4(simd_swizzle!(self.0, [3, 0, 1, 2]))
1944     }
1945 
1946     #[inline]
1947     #[must_use]
wxyw(self) -> Vec41948     fn wxyw(self) -> Vec4 {
1949         Vec4(simd_swizzle!(self.0, [3, 0, 1, 3]))
1950     }
1951 
1952     #[inline]
1953     #[must_use]
wxzx(self) -> Vec41954     fn wxzx(self) -> Vec4 {
1955         Vec4(simd_swizzle!(self.0, [3, 0, 2, 0]))
1956     }
1957 
1958     #[inline]
1959     #[must_use]
wxzy(self) -> Vec41960     fn wxzy(self) -> Vec4 {
1961         Vec4(simd_swizzle!(self.0, [3, 0, 2, 1]))
1962     }
1963 
1964     #[inline]
1965     #[must_use]
wxzz(self) -> Vec41966     fn wxzz(self) -> Vec4 {
1967         Vec4(simd_swizzle!(self.0, [3, 0, 2, 2]))
1968     }
1969 
1970     #[inline]
1971     #[must_use]
wxzw(self) -> Vec41972     fn wxzw(self) -> Vec4 {
1973         Vec4(simd_swizzle!(self.0, [3, 0, 2, 3]))
1974     }
1975 
1976     #[inline]
1977     #[must_use]
wxwx(self) -> Vec41978     fn wxwx(self) -> Vec4 {
1979         Vec4(simd_swizzle!(self.0, [3, 0, 3, 0]))
1980     }
1981 
1982     #[inline]
1983     #[must_use]
wxwy(self) -> Vec41984     fn wxwy(self) -> Vec4 {
1985         Vec4(simd_swizzle!(self.0, [3, 0, 3, 1]))
1986     }
1987 
1988     #[inline]
1989     #[must_use]
wxwz(self) -> Vec41990     fn wxwz(self) -> Vec4 {
1991         Vec4(simd_swizzle!(self.0, [3, 0, 3, 2]))
1992     }
1993 
1994     #[inline]
1995     #[must_use]
wxww(self) -> Vec41996     fn wxww(self) -> Vec4 {
1997         Vec4(simd_swizzle!(self.0, [3, 0, 3, 3]))
1998     }
1999 
2000     #[inline]
2001     #[must_use]
wyxx(self) -> Vec42002     fn wyxx(self) -> Vec4 {
2003         Vec4(simd_swizzle!(self.0, [3, 1, 0, 0]))
2004     }
2005 
2006     #[inline]
2007     #[must_use]
wyxy(self) -> Vec42008     fn wyxy(self) -> Vec4 {
2009         Vec4(simd_swizzle!(self.0, [3, 1, 0, 1]))
2010     }
2011 
2012     #[inline]
2013     #[must_use]
wyxz(self) -> Vec42014     fn wyxz(self) -> Vec4 {
2015         Vec4(simd_swizzle!(self.0, [3, 1, 0, 2]))
2016     }
2017 
2018     #[inline]
2019     #[must_use]
wyxw(self) -> Vec42020     fn wyxw(self) -> Vec4 {
2021         Vec4(simd_swizzle!(self.0, [3, 1, 0, 3]))
2022     }
2023 
2024     #[inline]
2025     #[must_use]
wyyx(self) -> Vec42026     fn wyyx(self) -> Vec4 {
2027         Vec4(simd_swizzle!(self.0, [3, 1, 1, 0]))
2028     }
2029 
2030     #[inline]
2031     #[must_use]
wyyy(self) -> Vec42032     fn wyyy(self) -> Vec4 {
2033         Vec4(simd_swizzle!(self.0, [3, 1, 1, 1]))
2034     }
2035 
2036     #[inline]
2037     #[must_use]
wyyz(self) -> Vec42038     fn wyyz(self) -> Vec4 {
2039         Vec4(simd_swizzle!(self.0, [3, 1, 1, 2]))
2040     }
2041 
2042     #[inline]
2043     #[must_use]
wyyw(self) -> Vec42044     fn wyyw(self) -> Vec4 {
2045         Vec4(simd_swizzle!(self.0, [3, 1, 1, 3]))
2046     }
2047 
2048     #[inline]
2049     #[must_use]
wyzx(self) -> Vec42050     fn wyzx(self) -> Vec4 {
2051         Vec4(simd_swizzle!(self.0, [3, 1, 2, 0]))
2052     }
2053 
2054     #[inline]
2055     #[must_use]
wyzy(self) -> Vec42056     fn wyzy(self) -> Vec4 {
2057         Vec4(simd_swizzle!(self.0, [3, 1, 2, 1]))
2058     }
2059 
2060     #[inline]
2061     #[must_use]
wyzz(self) -> Vec42062     fn wyzz(self) -> Vec4 {
2063         Vec4(simd_swizzle!(self.0, [3, 1, 2, 2]))
2064     }
2065 
2066     #[inline]
2067     #[must_use]
wyzw(self) -> Vec42068     fn wyzw(self) -> Vec4 {
2069         Vec4(simd_swizzle!(self.0, [3, 1, 2, 3]))
2070     }
2071 
2072     #[inline]
2073     #[must_use]
wywx(self) -> Vec42074     fn wywx(self) -> Vec4 {
2075         Vec4(simd_swizzle!(self.0, [3, 1, 3, 0]))
2076     }
2077 
2078     #[inline]
2079     #[must_use]
wywy(self) -> Vec42080     fn wywy(self) -> Vec4 {
2081         Vec4(simd_swizzle!(self.0, [3, 1, 3, 1]))
2082     }
2083 
2084     #[inline]
2085     #[must_use]
wywz(self) -> Vec42086     fn wywz(self) -> Vec4 {
2087         Vec4(simd_swizzle!(self.0, [3, 1, 3, 2]))
2088     }
2089 
2090     #[inline]
2091     #[must_use]
wyww(self) -> Vec42092     fn wyww(self) -> Vec4 {
2093         Vec4(simd_swizzle!(self.0, [3, 1, 3, 3]))
2094     }
2095 
2096     #[inline]
2097     #[must_use]
wzxx(self) -> Vec42098     fn wzxx(self) -> Vec4 {
2099         Vec4(simd_swizzle!(self.0, [3, 2, 0, 0]))
2100     }
2101 
2102     #[inline]
2103     #[must_use]
wzxy(self) -> Vec42104     fn wzxy(self) -> Vec4 {
2105         Vec4(simd_swizzle!(self.0, [3, 2, 0, 1]))
2106     }
2107 
2108     #[inline]
2109     #[must_use]
wzxz(self) -> Vec42110     fn wzxz(self) -> Vec4 {
2111         Vec4(simd_swizzle!(self.0, [3, 2, 0, 2]))
2112     }
2113 
2114     #[inline]
2115     #[must_use]
wzxw(self) -> Vec42116     fn wzxw(self) -> Vec4 {
2117         Vec4(simd_swizzle!(self.0, [3, 2, 0, 3]))
2118     }
2119 
2120     #[inline]
2121     #[must_use]
wzyx(self) -> Vec42122     fn wzyx(self) -> Vec4 {
2123         Vec4(simd_swizzle!(self.0, [3, 2, 1, 0]))
2124     }
2125 
2126     #[inline]
2127     #[must_use]
wzyy(self) -> Vec42128     fn wzyy(self) -> Vec4 {
2129         Vec4(simd_swizzle!(self.0, [3, 2, 1, 1]))
2130     }
2131 
2132     #[inline]
2133     #[must_use]
wzyz(self) -> Vec42134     fn wzyz(self) -> Vec4 {
2135         Vec4(simd_swizzle!(self.0, [3, 2, 1, 2]))
2136     }
2137 
2138     #[inline]
2139     #[must_use]
wzyw(self) -> Vec42140     fn wzyw(self) -> Vec4 {
2141         Vec4(simd_swizzle!(self.0, [3, 2, 1, 3]))
2142     }
2143 
2144     #[inline]
2145     #[must_use]
wzzx(self) -> Vec42146     fn wzzx(self) -> Vec4 {
2147         Vec4(simd_swizzle!(self.0, [3, 2, 2, 0]))
2148     }
2149 
2150     #[inline]
2151     #[must_use]
wzzy(self) -> Vec42152     fn wzzy(self) -> Vec4 {
2153         Vec4(simd_swizzle!(self.0, [3, 2, 2, 1]))
2154     }
2155 
2156     #[inline]
2157     #[must_use]
wzzz(self) -> Vec42158     fn wzzz(self) -> Vec4 {
2159         Vec4(simd_swizzle!(self.0, [3, 2, 2, 2]))
2160     }
2161 
2162     #[inline]
2163     #[must_use]
wzzw(self) -> Vec42164     fn wzzw(self) -> Vec4 {
2165         Vec4(simd_swizzle!(self.0, [3, 2, 2, 3]))
2166     }
2167 
2168     #[inline]
2169     #[must_use]
wzwx(self) -> Vec42170     fn wzwx(self) -> Vec4 {
2171         Vec4(simd_swizzle!(self.0, [3, 2, 3, 0]))
2172     }
2173 
2174     #[inline]
2175     #[must_use]
wzwy(self) -> Vec42176     fn wzwy(self) -> Vec4 {
2177         Vec4(simd_swizzle!(self.0, [3, 2, 3, 1]))
2178     }
2179 
2180     #[inline]
2181     #[must_use]
wzwz(self) -> Vec42182     fn wzwz(self) -> Vec4 {
2183         Vec4(simd_swizzle!(self.0, [3, 2, 3, 2]))
2184     }
2185 
2186     #[inline]
2187     #[must_use]
wzww(self) -> Vec42188     fn wzww(self) -> Vec4 {
2189         Vec4(simd_swizzle!(self.0, [3, 2, 3, 3]))
2190     }
2191 
2192     #[inline]
2193     #[must_use]
wwxx(self) -> Vec42194     fn wwxx(self) -> Vec4 {
2195         Vec4(simd_swizzle!(self.0, [3, 3, 0, 0]))
2196     }
2197 
2198     #[inline]
2199     #[must_use]
wwxy(self) -> Vec42200     fn wwxy(self) -> Vec4 {
2201         Vec4(simd_swizzle!(self.0, [3, 3, 0, 1]))
2202     }
2203 
2204     #[inline]
2205     #[must_use]
wwxz(self) -> Vec42206     fn wwxz(self) -> Vec4 {
2207         Vec4(simd_swizzle!(self.0, [3, 3, 0, 2]))
2208     }
2209 
2210     #[inline]
2211     #[must_use]
wwxw(self) -> Vec42212     fn wwxw(self) -> Vec4 {
2213         Vec4(simd_swizzle!(self.0, [3, 3, 0, 3]))
2214     }
2215 
2216     #[inline]
2217     #[must_use]
wwyx(self) -> Vec42218     fn wwyx(self) -> Vec4 {
2219         Vec4(simd_swizzle!(self.0, [3, 3, 1, 0]))
2220     }
2221 
2222     #[inline]
2223     #[must_use]
wwyy(self) -> Vec42224     fn wwyy(self) -> Vec4 {
2225         Vec4(simd_swizzle!(self.0, [3, 3, 1, 1]))
2226     }
2227 
2228     #[inline]
2229     #[must_use]
wwyz(self) -> Vec42230     fn wwyz(self) -> Vec4 {
2231         Vec4(simd_swizzle!(self.0, [3, 3, 1, 2]))
2232     }
2233 
2234     #[inline]
2235     #[must_use]
wwyw(self) -> Vec42236     fn wwyw(self) -> Vec4 {
2237         Vec4(simd_swizzle!(self.0, [3, 3, 1, 3]))
2238     }
2239 
2240     #[inline]
2241     #[must_use]
wwzx(self) -> Vec42242     fn wwzx(self) -> Vec4 {
2243         Vec4(simd_swizzle!(self.0, [3, 3, 2, 0]))
2244     }
2245 
2246     #[inline]
2247     #[must_use]
wwzy(self) -> Vec42248     fn wwzy(self) -> Vec4 {
2249         Vec4(simd_swizzle!(self.0, [3, 3, 2, 1]))
2250     }
2251 
2252     #[inline]
2253     #[must_use]
wwzz(self) -> Vec42254     fn wwzz(self) -> Vec4 {
2255         Vec4(simd_swizzle!(self.0, [3, 3, 2, 2]))
2256     }
2257 
2258     #[inline]
2259     #[must_use]
wwzw(self) -> Vec42260     fn wwzw(self) -> Vec4 {
2261         Vec4(simd_swizzle!(self.0, [3, 3, 2, 3]))
2262     }
2263 
2264     #[inline]
2265     #[must_use]
wwwx(self) -> Vec42266     fn wwwx(self) -> Vec4 {
2267         Vec4(simd_swizzle!(self.0, [3, 3, 3, 0]))
2268     }
2269 
2270     #[inline]
2271     #[must_use]
wwwy(self) -> Vec42272     fn wwwy(self) -> Vec4 {
2273         Vec4(simd_swizzle!(self.0, [3, 3, 3, 1]))
2274     }
2275 
2276     #[inline]
2277     #[must_use]
wwwz(self) -> Vec42278     fn wwwz(self) -> Vec4 {
2279         Vec4(simd_swizzle!(self.0, [3, 3, 3, 2]))
2280     }
2281 
2282     #[inline]
2283     #[must_use]
wwww(self) -> Vec42284     fn wwww(self) -> Vec4 {
2285         Vec4(simd_swizzle!(self.0, [3, 3, 3, 3]))
2286     }
2287 }
2288