Skip to main content

ptx_parser/unparser/instruction/
vop2.rs

1//! Original PTX specification:
2//!
3//! // SIMD instruction with secondary SIMD merge operation
4//! vop2.dtype.atype.btype{.sat}  d{.mask}, a{.asel}, b{.bsel}, c;
5//! // SIMD instruction with secondary accumulate operation
6//! vop2.dtype.atype.btype.add  d{.mask}, a{.asel}, b{.bsel}, c;
7//! vop2  = { vadd2, vsub2, vavrg2, vabsdiff2, vmin2, vmax2 };
8//! .dtype = .atype = .btype = { .u32, .s32 };
9//! .mask  = { .h0, .h1, .h10 };  // defaults to .h10
10//! .asel  = .bsel  = { .h00, .h01, .h02, .h03, .h10, .h11, .h12, .h13, .h20, .h21, .h22, .h23, .h30, .h31, .h32, .h33 };
11//! // .asel defaults to .h10
12//! // .bsel defaults to .h32
13
14#![allow(unused)]
15
16use crate::lexer::PtxToken;
17use crate::unparser::{PtxUnparser, common::*};
18
19pub mod section_0 {
20    use super::*;
21    use crate::r#type::instruction::vop2::section_0::*;
22
23    impl PtxUnparser for Vadd2DtypeAtypeBtypeSat {
24        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
25            self.unparse_tokens_mode(tokens, false);
26        }
27        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
28            push_opcode(tokens, "vadd2");
29            match &self.dtype {
30                Dtype::U32 => {
31                    push_directive(tokens, "u32");
32                }
33                Dtype::S32 => {
34                    push_directive(tokens, "s32");
35                }
36            }
37            match &self.atype {
38                Atype::U32 => {
39                    push_directive(tokens, "u32");
40                }
41                Atype::S32 => {
42                    push_directive(tokens, "s32");
43                }
44            }
45            match &self.btype {
46                Btype::U32 => {
47                    push_directive(tokens, "u32");
48                }
49                Btype::S32 => {
50                    push_directive(tokens, "s32");
51                }
52            }
53            if self.sat {
54                push_directive(tokens, "sat");
55            }
56            if spaced {
57                tokens.push(PtxToken::Space);
58            }
59            self.d.unparse_tokens_mode(tokens, spaced);
60            if let Some(mask_0) = self.mask.as_ref() {
61                match mask_0 {
62                    Mask::H10 => {
63                        push_directive(tokens, "h10");
64                    }
65                    Mask::H0 => {
66                        push_directive(tokens, "h0");
67                    }
68                    Mask::H1 => {
69                        push_directive(tokens, "h1");
70                    }
71                }
72            }
73            tokens.push(PtxToken::Comma);
74            if spaced {
75                tokens.push(PtxToken::Space);
76            }
77            self.a.unparse_tokens_mode(tokens, spaced);
78            if let Some(asel_1) = self.asel.as_ref() {
79                match asel_1 {
80                    Asel::H00 => {
81                        push_directive(tokens, "h00");
82                    }
83                    Asel::H01 => {
84                        push_directive(tokens, "h01");
85                    }
86                    Asel::H02 => {
87                        push_directive(tokens, "h02");
88                    }
89                    Asel::H03 => {
90                        push_directive(tokens, "h03");
91                    }
92                    Asel::H10 => {
93                        push_directive(tokens, "h10");
94                    }
95                    Asel::H11 => {
96                        push_directive(tokens, "h11");
97                    }
98                    Asel::H12 => {
99                        push_directive(tokens, "h12");
100                    }
101                    Asel::H13 => {
102                        push_directive(tokens, "h13");
103                    }
104                    Asel::H20 => {
105                        push_directive(tokens, "h20");
106                    }
107                    Asel::H21 => {
108                        push_directive(tokens, "h21");
109                    }
110                    Asel::H22 => {
111                        push_directive(tokens, "h22");
112                    }
113                    Asel::H23 => {
114                        push_directive(tokens, "h23");
115                    }
116                    Asel::H30 => {
117                        push_directive(tokens, "h30");
118                    }
119                    Asel::H31 => {
120                        push_directive(tokens, "h31");
121                    }
122                    Asel::H32 => {
123                        push_directive(tokens, "h32");
124                    }
125                    Asel::H33 => {
126                        push_directive(tokens, "h33");
127                    }
128                }
129            }
130            tokens.push(PtxToken::Comma);
131            if spaced {
132                tokens.push(PtxToken::Space);
133            }
134            self.b.unparse_tokens_mode(tokens, spaced);
135            if let Some(bsel_2) = self.bsel.as_ref() {
136                match bsel_2 {
137                    Bsel::H00 => {
138                        push_directive(tokens, "h00");
139                    }
140                    Bsel::H01 => {
141                        push_directive(tokens, "h01");
142                    }
143                    Bsel::H02 => {
144                        push_directive(tokens, "h02");
145                    }
146                    Bsel::H03 => {
147                        push_directive(tokens, "h03");
148                    }
149                    Bsel::H10 => {
150                        push_directive(tokens, "h10");
151                    }
152                    Bsel::H11 => {
153                        push_directive(tokens, "h11");
154                    }
155                    Bsel::H12 => {
156                        push_directive(tokens, "h12");
157                    }
158                    Bsel::H13 => {
159                        push_directive(tokens, "h13");
160                    }
161                    Bsel::H20 => {
162                        push_directive(tokens, "h20");
163                    }
164                    Bsel::H21 => {
165                        push_directive(tokens, "h21");
166                    }
167                    Bsel::H22 => {
168                        push_directive(tokens, "h22");
169                    }
170                    Bsel::H23 => {
171                        push_directive(tokens, "h23");
172                    }
173                    Bsel::H30 => {
174                        push_directive(tokens, "h30");
175                    }
176                    Bsel::H31 => {
177                        push_directive(tokens, "h31");
178                    }
179                    Bsel::H32 => {
180                        push_directive(tokens, "h32");
181                    }
182                    Bsel::H33 => {
183                        push_directive(tokens, "h33");
184                    }
185                }
186            }
187            tokens.push(PtxToken::Comma);
188            if spaced {
189                tokens.push(PtxToken::Space);
190            }
191            self.c.unparse_tokens_mode(tokens, spaced);
192            tokens.push(PtxToken::Semicolon);
193            if spaced {
194                tokens.push(PtxToken::Newline);
195            }
196        }
197    }
198
199    impl PtxUnparser for Vsub2DtypeAtypeBtypeSat {
200        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
201            self.unparse_tokens_mode(tokens, false);
202        }
203        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
204            push_opcode(tokens, "vsub2");
205            match &self.dtype {
206                Dtype::U32 => {
207                    push_directive(tokens, "u32");
208                }
209                Dtype::S32 => {
210                    push_directive(tokens, "s32");
211                }
212            }
213            match &self.atype {
214                Atype::U32 => {
215                    push_directive(tokens, "u32");
216                }
217                Atype::S32 => {
218                    push_directive(tokens, "s32");
219                }
220            }
221            match &self.btype {
222                Btype::U32 => {
223                    push_directive(tokens, "u32");
224                }
225                Btype::S32 => {
226                    push_directive(tokens, "s32");
227                }
228            }
229            if self.sat {
230                push_directive(tokens, "sat");
231            }
232            if spaced {
233                tokens.push(PtxToken::Space);
234            }
235            self.d.unparse_tokens_mode(tokens, spaced);
236            if let Some(mask_3) = self.mask.as_ref() {
237                match mask_3 {
238                    Mask::H10 => {
239                        push_directive(tokens, "h10");
240                    }
241                    Mask::H0 => {
242                        push_directive(tokens, "h0");
243                    }
244                    Mask::H1 => {
245                        push_directive(tokens, "h1");
246                    }
247                }
248            }
249            tokens.push(PtxToken::Comma);
250            if spaced {
251                tokens.push(PtxToken::Space);
252            }
253            self.a.unparse_tokens_mode(tokens, spaced);
254            if let Some(asel_4) = self.asel.as_ref() {
255                match asel_4 {
256                    Asel::H00 => {
257                        push_directive(tokens, "h00");
258                    }
259                    Asel::H01 => {
260                        push_directive(tokens, "h01");
261                    }
262                    Asel::H02 => {
263                        push_directive(tokens, "h02");
264                    }
265                    Asel::H03 => {
266                        push_directive(tokens, "h03");
267                    }
268                    Asel::H10 => {
269                        push_directive(tokens, "h10");
270                    }
271                    Asel::H11 => {
272                        push_directive(tokens, "h11");
273                    }
274                    Asel::H12 => {
275                        push_directive(tokens, "h12");
276                    }
277                    Asel::H13 => {
278                        push_directive(tokens, "h13");
279                    }
280                    Asel::H20 => {
281                        push_directive(tokens, "h20");
282                    }
283                    Asel::H21 => {
284                        push_directive(tokens, "h21");
285                    }
286                    Asel::H22 => {
287                        push_directive(tokens, "h22");
288                    }
289                    Asel::H23 => {
290                        push_directive(tokens, "h23");
291                    }
292                    Asel::H30 => {
293                        push_directive(tokens, "h30");
294                    }
295                    Asel::H31 => {
296                        push_directive(tokens, "h31");
297                    }
298                    Asel::H32 => {
299                        push_directive(tokens, "h32");
300                    }
301                    Asel::H33 => {
302                        push_directive(tokens, "h33");
303                    }
304                }
305            }
306            tokens.push(PtxToken::Comma);
307            if spaced {
308                tokens.push(PtxToken::Space);
309            }
310            self.b.unparse_tokens_mode(tokens, spaced);
311            if let Some(bsel_5) = self.bsel.as_ref() {
312                match bsel_5 {
313                    Bsel::H00 => {
314                        push_directive(tokens, "h00");
315                    }
316                    Bsel::H01 => {
317                        push_directive(tokens, "h01");
318                    }
319                    Bsel::H02 => {
320                        push_directive(tokens, "h02");
321                    }
322                    Bsel::H03 => {
323                        push_directive(tokens, "h03");
324                    }
325                    Bsel::H10 => {
326                        push_directive(tokens, "h10");
327                    }
328                    Bsel::H11 => {
329                        push_directive(tokens, "h11");
330                    }
331                    Bsel::H12 => {
332                        push_directive(tokens, "h12");
333                    }
334                    Bsel::H13 => {
335                        push_directive(tokens, "h13");
336                    }
337                    Bsel::H20 => {
338                        push_directive(tokens, "h20");
339                    }
340                    Bsel::H21 => {
341                        push_directive(tokens, "h21");
342                    }
343                    Bsel::H22 => {
344                        push_directive(tokens, "h22");
345                    }
346                    Bsel::H23 => {
347                        push_directive(tokens, "h23");
348                    }
349                    Bsel::H30 => {
350                        push_directive(tokens, "h30");
351                    }
352                    Bsel::H31 => {
353                        push_directive(tokens, "h31");
354                    }
355                    Bsel::H32 => {
356                        push_directive(tokens, "h32");
357                    }
358                    Bsel::H33 => {
359                        push_directive(tokens, "h33");
360                    }
361                }
362            }
363            tokens.push(PtxToken::Comma);
364            if spaced {
365                tokens.push(PtxToken::Space);
366            }
367            self.c.unparse_tokens_mode(tokens, spaced);
368            tokens.push(PtxToken::Semicolon);
369            if spaced {
370                tokens.push(PtxToken::Newline);
371            }
372        }
373    }
374
375    impl PtxUnparser for Vavrg2DtypeAtypeBtypeSat {
376        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
377            self.unparse_tokens_mode(tokens, false);
378        }
379        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
380            push_opcode(tokens, "vavrg2");
381            match &self.dtype {
382                Dtype::U32 => {
383                    push_directive(tokens, "u32");
384                }
385                Dtype::S32 => {
386                    push_directive(tokens, "s32");
387                }
388            }
389            match &self.atype {
390                Atype::U32 => {
391                    push_directive(tokens, "u32");
392                }
393                Atype::S32 => {
394                    push_directive(tokens, "s32");
395                }
396            }
397            match &self.btype {
398                Btype::U32 => {
399                    push_directive(tokens, "u32");
400                }
401                Btype::S32 => {
402                    push_directive(tokens, "s32");
403                }
404            }
405            if self.sat {
406                push_directive(tokens, "sat");
407            }
408            if spaced {
409                tokens.push(PtxToken::Space);
410            }
411            self.d.unparse_tokens_mode(tokens, spaced);
412            if let Some(mask_6) = self.mask.as_ref() {
413                match mask_6 {
414                    Mask::H10 => {
415                        push_directive(tokens, "h10");
416                    }
417                    Mask::H0 => {
418                        push_directive(tokens, "h0");
419                    }
420                    Mask::H1 => {
421                        push_directive(tokens, "h1");
422                    }
423                }
424            }
425            tokens.push(PtxToken::Comma);
426            if spaced {
427                tokens.push(PtxToken::Space);
428            }
429            self.a.unparse_tokens_mode(tokens, spaced);
430            if let Some(asel_7) = self.asel.as_ref() {
431                match asel_7 {
432                    Asel::H00 => {
433                        push_directive(tokens, "h00");
434                    }
435                    Asel::H01 => {
436                        push_directive(tokens, "h01");
437                    }
438                    Asel::H02 => {
439                        push_directive(tokens, "h02");
440                    }
441                    Asel::H03 => {
442                        push_directive(tokens, "h03");
443                    }
444                    Asel::H10 => {
445                        push_directive(tokens, "h10");
446                    }
447                    Asel::H11 => {
448                        push_directive(tokens, "h11");
449                    }
450                    Asel::H12 => {
451                        push_directive(tokens, "h12");
452                    }
453                    Asel::H13 => {
454                        push_directive(tokens, "h13");
455                    }
456                    Asel::H20 => {
457                        push_directive(tokens, "h20");
458                    }
459                    Asel::H21 => {
460                        push_directive(tokens, "h21");
461                    }
462                    Asel::H22 => {
463                        push_directive(tokens, "h22");
464                    }
465                    Asel::H23 => {
466                        push_directive(tokens, "h23");
467                    }
468                    Asel::H30 => {
469                        push_directive(tokens, "h30");
470                    }
471                    Asel::H31 => {
472                        push_directive(tokens, "h31");
473                    }
474                    Asel::H32 => {
475                        push_directive(tokens, "h32");
476                    }
477                    Asel::H33 => {
478                        push_directive(tokens, "h33");
479                    }
480                }
481            }
482            tokens.push(PtxToken::Comma);
483            if spaced {
484                tokens.push(PtxToken::Space);
485            }
486            self.b.unparse_tokens_mode(tokens, spaced);
487            if let Some(bsel_8) = self.bsel.as_ref() {
488                match bsel_8 {
489                    Bsel::H00 => {
490                        push_directive(tokens, "h00");
491                    }
492                    Bsel::H01 => {
493                        push_directive(tokens, "h01");
494                    }
495                    Bsel::H02 => {
496                        push_directive(tokens, "h02");
497                    }
498                    Bsel::H03 => {
499                        push_directive(tokens, "h03");
500                    }
501                    Bsel::H10 => {
502                        push_directive(tokens, "h10");
503                    }
504                    Bsel::H11 => {
505                        push_directive(tokens, "h11");
506                    }
507                    Bsel::H12 => {
508                        push_directive(tokens, "h12");
509                    }
510                    Bsel::H13 => {
511                        push_directive(tokens, "h13");
512                    }
513                    Bsel::H20 => {
514                        push_directive(tokens, "h20");
515                    }
516                    Bsel::H21 => {
517                        push_directive(tokens, "h21");
518                    }
519                    Bsel::H22 => {
520                        push_directive(tokens, "h22");
521                    }
522                    Bsel::H23 => {
523                        push_directive(tokens, "h23");
524                    }
525                    Bsel::H30 => {
526                        push_directive(tokens, "h30");
527                    }
528                    Bsel::H31 => {
529                        push_directive(tokens, "h31");
530                    }
531                    Bsel::H32 => {
532                        push_directive(tokens, "h32");
533                    }
534                    Bsel::H33 => {
535                        push_directive(tokens, "h33");
536                    }
537                }
538            }
539            tokens.push(PtxToken::Comma);
540            if spaced {
541                tokens.push(PtxToken::Space);
542            }
543            self.c.unparse_tokens_mode(tokens, spaced);
544            tokens.push(PtxToken::Semicolon);
545            if spaced {
546                tokens.push(PtxToken::Newline);
547            }
548        }
549    }
550
551    impl PtxUnparser for Vabsdiff2DtypeAtypeBtypeSat {
552        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
553            self.unparse_tokens_mode(tokens, false);
554        }
555        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
556            push_opcode(tokens, "vabsdiff2");
557            match &self.dtype {
558                Dtype::U32 => {
559                    push_directive(tokens, "u32");
560                }
561                Dtype::S32 => {
562                    push_directive(tokens, "s32");
563                }
564            }
565            match &self.atype {
566                Atype::U32 => {
567                    push_directive(tokens, "u32");
568                }
569                Atype::S32 => {
570                    push_directive(tokens, "s32");
571                }
572            }
573            match &self.btype {
574                Btype::U32 => {
575                    push_directive(tokens, "u32");
576                }
577                Btype::S32 => {
578                    push_directive(tokens, "s32");
579                }
580            }
581            if self.sat {
582                push_directive(tokens, "sat");
583            }
584            if spaced {
585                tokens.push(PtxToken::Space);
586            }
587            self.d.unparse_tokens_mode(tokens, spaced);
588            if let Some(mask_9) = self.mask.as_ref() {
589                match mask_9 {
590                    Mask::H10 => {
591                        push_directive(tokens, "h10");
592                    }
593                    Mask::H0 => {
594                        push_directive(tokens, "h0");
595                    }
596                    Mask::H1 => {
597                        push_directive(tokens, "h1");
598                    }
599                }
600            }
601            tokens.push(PtxToken::Comma);
602            if spaced {
603                tokens.push(PtxToken::Space);
604            }
605            self.a.unparse_tokens_mode(tokens, spaced);
606            if let Some(asel_10) = self.asel.as_ref() {
607                match asel_10 {
608                    Asel::H00 => {
609                        push_directive(tokens, "h00");
610                    }
611                    Asel::H01 => {
612                        push_directive(tokens, "h01");
613                    }
614                    Asel::H02 => {
615                        push_directive(tokens, "h02");
616                    }
617                    Asel::H03 => {
618                        push_directive(tokens, "h03");
619                    }
620                    Asel::H10 => {
621                        push_directive(tokens, "h10");
622                    }
623                    Asel::H11 => {
624                        push_directive(tokens, "h11");
625                    }
626                    Asel::H12 => {
627                        push_directive(tokens, "h12");
628                    }
629                    Asel::H13 => {
630                        push_directive(tokens, "h13");
631                    }
632                    Asel::H20 => {
633                        push_directive(tokens, "h20");
634                    }
635                    Asel::H21 => {
636                        push_directive(tokens, "h21");
637                    }
638                    Asel::H22 => {
639                        push_directive(tokens, "h22");
640                    }
641                    Asel::H23 => {
642                        push_directive(tokens, "h23");
643                    }
644                    Asel::H30 => {
645                        push_directive(tokens, "h30");
646                    }
647                    Asel::H31 => {
648                        push_directive(tokens, "h31");
649                    }
650                    Asel::H32 => {
651                        push_directive(tokens, "h32");
652                    }
653                    Asel::H33 => {
654                        push_directive(tokens, "h33");
655                    }
656                }
657            }
658            tokens.push(PtxToken::Comma);
659            if spaced {
660                tokens.push(PtxToken::Space);
661            }
662            self.b.unparse_tokens_mode(tokens, spaced);
663            if let Some(bsel_11) = self.bsel.as_ref() {
664                match bsel_11 {
665                    Bsel::H00 => {
666                        push_directive(tokens, "h00");
667                    }
668                    Bsel::H01 => {
669                        push_directive(tokens, "h01");
670                    }
671                    Bsel::H02 => {
672                        push_directive(tokens, "h02");
673                    }
674                    Bsel::H03 => {
675                        push_directive(tokens, "h03");
676                    }
677                    Bsel::H10 => {
678                        push_directive(tokens, "h10");
679                    }
680                    Bsel::H11 => {
681                        push_directive(tokens, "h11");
682                    }
683                    Bsel::H12 => {
684                        push_directive(tokens, "h12");
685                    }
686                    Bsel::H13 => {
687                        push_directive(tokens, "h13");
688                    }
689                    Bsel::H20 => {
690                        push_directive(tokens, "h20");
691                    }
692                    Bsel::H21 => {
693                        push_directive(tokens, "h21");
694                    }
695                    Bsel::H22 => {
696                        push_directive(tokens, "h22");
697                    }
698                    Bsel::H23 => {
699                        push_directive(tokens, "h23");
700                    }
701                    Bsel::H30 => {
702                        push_directive(tokens, "h30");
703                    }
704                    Bsel::H31 => {
705                        push_directive(tokens, "h31");
706                    }
707                    Bsel::H32 => {
708                        push_directive(tokens, "h32");
709                    }
710                    Bsel::H33 => {
711                        push_directive(tokens, "h33");
712                    }
713                }
714            }
715            tokens.push(PtxToken::Comma);
716            if spaced {
717                tokens.push(PtxToken::Space);
718            }
719            self.c.unparse_tokens_mode(tokens, spaced);
720            tokens.push(PtxToken::Semicolon);
721            if spaced {
722                tokens.push(PtxToken::Newline);
723            }
724        }
725    }
726
727    impl PtxUnparser for Vmin2DtypeAtypeBtypeSat {
728        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
729            self.unparse_tokens_mode(tokens, false);
730        }
731        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
732            push_opcode(tokens, "vmin2");
733            match &self.dtype {
734                Dtype::U32 => {
735                    push_directive(tokens, "u32");
736                }
737                Dtype::S32 => {
738                    push_directive(tokens, "s32");
739                }
740            }
741            match &self.atype {
742                Atype::U32 => {
743                    push_directive(tokens, "u32");
744                }
745                Atype::S32 => {
746                    push_directive(tokens, "s32");
747                }
748            }
749            match &self.btype {
750                Btype::U32 => {
751                    push_directive(tokens, "u32");
752                }
753                Btype::S32 => {
754                    push_directive(tokens, "s32");
755                }
756            }
757            if self.sat {
758                push_directive(tokens, "sat");
759            }
760            if spaced {
761                tokens.push(PtxToken::Space);
762            }
763            self.d.unparse_tokens_mode(tokens, spaced);
764            if let Some(mask_12) = self.mask.as_ref() {
765                match mask_12 {
766                    Mask::H10 => {
767                        push_directive(tokens, "h10");
768                    }
769                    Mask::H0 => {
770                        push_directive(tokens, "h0");
771                    }
772                    Mask::H1 => {
773                        push_directive(tokens, "h1");
774                    }
775                }
776            }
777            tokens.push(PtxToken::Comma);
778            if spaced {
779                tokens.push(PtxToken::Space);
780            }
781            self.a.unparse_tokens_mode(tokens, spaced);
782            if let Some(asel_13) = self.asel.as_ref() {
783                match asel_13 {
784                    Asel::H00 => {
785                        push_directive(tokens, "h00");
786                    }
787                    Asel::H01 => {
788                        push_directive(tokens, "h01");
789                    }
790                    Asel::H02 => {
791                        push_directive(tokens, "h02");
792                    }
793                    Asel::H03 => {
794                        push_directive(tokens, "h03");
795                    }
796                    Asel::H10 => {
797                        push_directive(tokens, "h10");
798                    }
799                    Asel::H11 => {
800                        push_directive(tokens, "h11");
801                    }
802                    Asel::H12 => {
803                        push_directive(tokens, "h12");
804                    }
805                    Asel::H13 => {
806                        push_directive(tokens, "h13");
807                    }
808                    Asel::H20 => {
809                        push_directive(tokens, "h20");
810                    }
811                    Asel::H21 => {
812                        push_directive(tokens, "h21");
813                    }
814                    Asel::H22 => {
815                        push_directive(tokens, "h22");
816                    }
817                    Asel::H23 => {
818                        push_directive(tokens, "h23");
819                    }
820                    Asel::H30 => {
821                        push_directive(tokens, "h30");
822                    }
823                    Asel::H31 => {
824                        push_directive(tokens, "h31");
825                    }
826                    Asel::H32 => {
827                        push_directive(tokens, "h32");
828                    }
829                    Asel::H33 => {
830                        push_directive(tokens, "h33");
831                    }
832                }
833            }
834            tokens.push(PtxToken::Comma);
835            if spaced {
836                tokens.push(PtxToken::Space);
837            }
838            self.b.unparse_tokens_mode(tokens, spaced);
839            if let Some(bsel_14) = self.bsel.as_ref() {
840                match bsel_14 {
841                    Bsel::H00 => {
842                        push_directive(tokens, "h00");
843                    }
844                    Bsel::H01 => {
845                        push_directive(tokens, "h01");
846                    }
847                    Bsel::H02 => {
848                        push_directive(tokens, "h02");
849                    }
850                    Bsel::H03 => {
851                        push_directive(tokens, "h03");
852                    }
853                    Bsel::H10 => {
854                        push_directive(tokens, "h10");
855                    }
856                    Bsel::H11 => {
857                        push_directive(tokens, "h11");
858                    }
859                    Bsel::H12 => {
860                        push_directive(tokens, "h12");
861                    }
862                    Bsel::H13 => {
863                        push_directive(tokens, "h13");
864                    }
865                    Bsel::H20 => {
866                        push_directive(tokens, "h20");
867                    }
868                    Bsel::H21 => {
869                        push_directive(tokens, "h21");
870                    }
871                    Bsel::H22 => {
872                        push_directive(tokens, "h22");
873                    }
874                    Bsel::H23 => {
875                        push_directive(tokens, "h23");
876                    }
877                    Bsel::H30 => {
878                        push_directive(tokens, "h30");
879                    }
880                    Bsel::H31 => {
881                        push_directive(tokens, "h31");
882                    }
883                    Bsel::H32 => {
884                        push_directive(tokens, "h32");
885                    }
886                    Bsel::H33 => {
887                        push_directive(tokens, "h33");
888                    }
889                }
890            }
891            tokens.push(PtxToken::Comma);
892            if spaced {
893                tokens.push(PtxToken::Space);
894            }
895            self.c.unparse_tokens_mode(tokens, spaced);
896            tokens.push(PtxToken::Semicolon);
897            if spaced {
898                tokens.push(PtxToken::Newline);
899            }
900        }
901    }
902
903    impl PtxUnparser for Vmax2DtypeAtypeBtypeSat {
904        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
905            self.unparse_tokens_mode(tokens, false);
906        }
907        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
908            push_opcode(tokens, "vmax2");
909            match &self.dtype {
910                Dtype::U32 => {
911                    push_directive(tokens, "u32");
912                }
913                Dtype::S32 => {
914                    push_directive(tokens, "s32");
915                }
916            }
917            match &self.atype {
918                Atype::U32 => {
919                    push_directive(tokens, "u32");
920                }
921                Atype::S32 => {
922                    push_directive(tokens, "s32");
923                }
924            }
925            match &self.btype {
926                Btype::U32 => {
927                    push_directive(tokens, "u32");
928                }
929                Btype::S32 => {
930                    push_directive(tokens, "s32");
931                }
932            }
933            if self.sat {
934                push_directive(tokens, "sat");
935            }
936            if spaced {
937                tokens.push(PtxToken::Space);
938            }
939            self.d.unparse_tokens_mode(tokens, spaced);
940            if let Some(mask_15) = self.mask.as_ref() {
941                match mask_15 {
942                    Mask::H10 => {
943                        push_directive(tokens, "h10");
944                    }
945                    Mask::H0 => {
946                        push_directive(tokens, "h0");
947                    }
948                    Mask::H1 => {
949                        push_directive(tokens, "h1");
950                    }
951                }
952            }
953            tokens.push(PtxToken::Comma);
954            if spaced {
955                tokens.push(PtxToken::Space);
956            }
957            self.a.unparse_tokens_mode(tokens, spaced);
958            if let Some(asel_16) = self.asel.as_ref() {
959                match asel_16 {
960                    Asel::H00 => {
961                        push_directive(tokens, "h00");
962                    }
963                    Asel::H01 => {
964                        push_directive(tokens, "h01");
965                    }
966                    Asel::H02 => {
967                        push_directive(tokens, "h02");
968                    }
969                    Asel::H03 => {
970                        push_directive(tokens, "h03");
971                    }
972                    Asel::H10 => {
973                        push_directive(tokens, "h10");
974                    }
975                    Asel::H11 => {
976                        push_directive(tokens, "h11");
977                    }
978                    Asel::H12 => {
979                        push_directive(tokens, "h12");
980                    }
981                    Asel::H13 => {
982                        push_directive(tokens, "h13");
983                    }
984                    Asel::H20 => {
985                        push_directive(tokens, "h20");
986                    }
987                    Asel::H21 => {
988                        push_directive(tokens, "h21");
989                    }
990                    Asel::H22 => {
991                        push_directive(tokens, "h22");
992                    }
993                    Asel::H23 => {
994                        push_directive(tokens, "h23");
995                    }
996                    Asel::H30 => {
997                        push_directive(tokens, "h30");
998                    }
999                    Asel::H31 => {
1000                        push_directive(tokens, "h31");
1001                    }
1002                    Asel::H32 => {
1003                        push_directive(tokens, "h32");
1004                    }
1005                    Asel::H33 => {
1006                        push_directive(tokens, "h33");
1007                    }
1008                }
1009            }
1010            tokens.push(PtxToken::Comma);
1011            if spaced {
1012                tokens.push(PtxToken::Space);
1013            }
1014            self.b.unparse_tokens_mode(tokens, spaced);
1015            if let Some(bsel_17) = self.bsel.as_ref() {
1016                match bsel_17 {
1017                    Bsel::H00 => {
1018                        push_directive(tokens, "h00");
1019                    }
1020                    Bsel::H01 => {
1021                        push_directive(tokens, "h01");
1022                    }
1023                    Bsel::H02 => {
1024                        push_directive(tokens, "h02");
1025                    }
1026                    Bsel::H03 => {
1027                        push_directive(tokens, "h03");
1028                    }
1029                    Bsel::H10 => {
1030                        push_directive(tokens, "h10");
1031                    }
1032                    Bsel::H11 => {
1033                        push_directive(tokens, "h11");
1034                    }
1035                    Bsel::H12 => {
1036                        push_directive(tokens, "h12");
1037                    }
1038                    Bsel::H13 => {
1039                        push_directive(tokens, "h13");
1040                    }
1041                    Bsel::H20 => {
1042                        push_directive(tokens, "h20");
1043                    }
1044                    Bsel::H21 => {
1045                        push_directive(tokens, "h21");
1046                    }
1047                    Bsel::H22 => {
1048                        push_directive(tokens, "h22");
1049                    }
1050                    Bsel::H23 => {
1051                        push_directive(tokens, "h23");
1052                    }
1053                    Bsel::H30 => {
1054                        push_directive(tokens, "h30");
1055                    }
1056                    Bsel::H31 => {
1057                        push_directive(tokens, "h31");
1058                    }
1059                    Bsel::H32 => {
1060                        push_directive(tokens, "h32");
1061                    }
1062                    Bsel::H33 => {
1063                        push_directive(tokens, "h33");
1064                    }
1065                }
1066            }
1067            tokens.push(PtxToken::Comma);
1068            if spaced {
1069                tokens.push(PtxToken::Space);
1070            }
1071            self.c.unparse_tokens_mode(tokens, spaced);
1072            tokens.push(PtxToken::Semicolon);
1073            if spaced {
1074                tokens.push(PtxToken::Newline);
1075            }
1076        }
1077    }
1078
1079    impl PtxUnparser for Vadd2DtypeAtypeBtypeAdd {
1080        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1081            self.unparse_tokens_mode(tokens, false);
1082        }
1083        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1084            push_opcode(tokens, "vadd2");
1085            match &self.dtype {
1086                Dtype::U32 => {
1087                    push_directive(tokens, "u32");
1088                }
1089                Dtype::S32 => {
1090                    push_directive(tokens, "s32");
1091                }
1092            }
1093            match &self.atype {
1094                Atype::U32 => {
1095                    push_directive(tokens, "u32");
1096                }
1097                Atype::S32 => {
1098                    push_directive(tokens, "s32");
1099                }
1100            }
1101            match &self.btype {
1102                Btype::U32 => {
1103                    push_directive(tokens, "u32");
1104                }
1105                Btype::S32 => {
1106                    push_directive(tokens, "s32");
1107                }
1108            }
1109            push_directive(tokens, "add");
1110            if spaced {
1111                tokens.push(PtxToken::Space);
1112            }
1113            self.d.unparse_tokens_mode(tokens, spaced);
1114            if let Some(mask_18) = self.mask.as_ref() {
1115                match mask_18 {
1116                    Mask::H10 => {
1117                        push_directive(tokens, "h10");
1118                    }
1119                    Mask::H0 => {
1120                        push_directive(tokens, "h0");
1121                    }
1122                    Mask::H1 => {
1123                        push_directive(tokens, "h1");
1124                    }
1125                }
1126            }
1127            tokens.push(PtxToken::Comma);
1128            if spaced {
1129                tokens.push(PtxToken::Space);
1130            }
1131            self.a.unparse_tokens_mode(tokens, spaced);
1132            if let Some(asel_19) = self.asel.as_ref() {
1133                match asel_19 {
1134                    Asel::H00 => {
1135                        push_directive(tokens, "h00");
1136                    }
1137                    Asel::H01 => {
1138                        push_directive(tokens, "h01");
1139                    }
1140                    Asel::H02 => {
1141                        push_directive(tokens, "h02");
1142                    }
1143                    Asel::H03 => {
1144                        push_directive(tokens, "h03");
1145                    }
1146                    Asel::H10 => {
1147                        push_directive(tokens, "h10");
1148                    }
1149                    Asel::H11 => {
1150                        push_directive(tokens, "h11");
1151                    }
1152                    Asel::H12 => {
1153                        push_directive(tokens, "h12");
1154                    }
1155                    Asel::H13 => {
1156                        push_directive(tokens, "h13");
1157                    }
1158                    Asel::H20 => {
1159                        push_directive(tokens, "h20");
1160                    }
1161                    Asel::H21 => {
1162                        push_directive(tokens, "h21");
1163                    }
1164                    Asel::H22 => {
1165                        push_directive(tokens, "h22");
1166                    }
1167                    Asel::H23 => {
1168                        push_directive(tokens, "h23");
1169                    }
1170                    Asel::H30 => {
1171                        push_directive(tokens, "h30");
1172                    }
1173                    Asel::H31 => {
1174                        push_directive(tokens, "h31");
1175                    }
1176                    Asel::H32 => {
1177                        push_directive(tokens, "h32");
1178                    }
1179                    Asel::H33 => {
1180                        push_directive(tokens, "h33");
1181                    }
1182                }
1183            }
1184            tokens.push(PtxToken::Comma);
1185            if spaced {
1186                tokens.push(PtxToken::Space);
1187            }
1188            self.b.unparse_tokens_mode(tokens, spaced);
1189            if let Some(bsel_20) = self.bsel.as_ref() {
1190                match bsel_20 {
1191                    Bsel::H00 => {
1192                        push_directive(tokens, "h00");
1193                    }
1194                    Bsel::H01 => {
1195                        push_directive(tokens, "h01");
1196                    }
1197                    Bsel::H02 => {
1198                        push_directive(tokens, "h02");
1199                    }
1200                    Bsel::H03 => {
1201                        push_directive(tokens, "h03");
1202                    }
1203                    Bsel::H10 => {
1204                        push_directive(tokens, "h10");
1205                    }
1206                    Bsel::H11 => {
1207                        push_directive(tokens, "h11");
1208                    }
1209                    Bsel::H12 => {
1210                        push_directive(tokens, "h12");
1211                    }
1212                    Bsel::H13 => {
1213                        push_directive(tokens, "h13");
1214                    }
1215                    Bsel::H20 => {
1216                        push_directive(tokens, "h20");
1217                    }
1218                    Bsel::H21 => {
1219                        push_directive(tokens, "h21");
1220                    }
1221                    Bsel::H22 => {
1222                        push_directive(tokens, "h22");
1223                    }
1224                    Bsel::H23 => {
1225                        push_directive(tokens, "h23");
1226                    }
1227                    Bsel::H30 => {
1228                        push_directive(tokens, "h30");
1229                    }
1230                    Bsel::H31 => {
1231                        push_directive(tokens, "h31");
1232                    }
1233                    Bsel::H32 => {
1234                        push_directive(tokens, "h32");
1235                    }
1236                    Bsel::H33 => {
1237                        push_directive(tokens, "h33");
1238                    }
1239                }
1240            }
1241            tokens.push(PtxToken::Comma);
1242            if spaced {
1243                tokens.push(PtxToken::Space);
1244            }
1245            self.c.unparse_tokens_mode(tokens, spaced);
1246            tokens.push(PtxToken::Semicolon);
1247            if spaced {
1248                tokens.push(PtxToken::Newline);
1249            }
1250        }
1251    }
1252
1253    impl PtxUnparser for Vsub2DtypeAtypeBtypeAdd {
1254        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1255            self.unparse_tokens_mode(tokens, false);
1256        }
1257        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1258            push_opcode(tokens, "vsub2");
1259            match &self.dtype {
1260                Dtype::U32 => {
1261                    push_directive(tokens, "u32");
1262                }
1263                Dtype::S32 => {
1264                    push_directive(tokens, "s32");
1265                }
1266            }
1267            match &self.atype {
1268                Atype::U32 => {
1269                    push_directive(tokens, "u32");
1270                }
1271                Atype::S32 => {
1272                    push_directive(tokens, "s32");
1273                }
1274            }
1275            match &self.btype {
1276                Btype::U32 => {
1277                    push_directive(tokens, "u32");
1278                }
1279                Btype::S32 => {
1280                    push_directive(tokens, "s32");
1281                }
1282            }
1283            push_directive(tokens, "add");
1284            if spaced {
1285                tokens.push(PtxToken::Space);
1286            }
1287            self.d.unparse_tokens_mode(tokens, spaced);
1288            if let Some(mask_21) = self.mask.as_ref() {
1289                match mask_21 {
1290                    Mask::H10 => {
1291                        push_directive(tokens, "h10");
1292                    }
1293                    Mask::H0 => {
1294                        push_directive(tokens, "h0");
1295                    }
1296                    Mask::H1 => {
1297                        push_directive(tokens, "h1");
1298                    }
1299                }
1300            }
1301            tokens.push(PtxToken::Comma);
1302            if spaced {
1303                tokens.push(PtxToken::Space);
1304            }
1305            self.a.unparse_tokens_mode(tokens, spaced);
1306            if let Some(asel_22) = self.asel.as_ref() {
1307                match asel_22 {
1308                    Asel::H00 => {
1309                        push_directive(tokens, "h00");
1310                    }
1311                    Asel::H01 => {
1312                        push_directive(tokens, "h01");
1313                    }
1314                    Asel::H02 => {
1315                        push_directive(tokens, "h02");
1316                    }
1317                    Asel::H03 => {
1318                        push_directive(tokens, "h03");
1319                    }
1320                    Asel::H10 => {
1321                        push_directive(tokens, "h10");
1322                    }
1323                    Asel::H11 => {
1324                        push_directive(tokens, "h11");
1325                    }
1326                    Asel::H12 => {
1327                        push_directive(tokens, "h12");
1328                    }
1329                    Asel::H13 => {
1330                        push_directive(tokens, "h13");
1331                    }
1332                    Asel::H20 => {
1333                        push_directive(tokens, "h20");
1334                    }
1335                    Asel::H21 => {
1336                        push_directive(tokens, "h21");
1337                    }
1338                    Asel::H22 => {
1339                        push_directive(tokens, "h22");
1340                    }
1341                    Asel::H23 => {
1342                        push_directive(tokens, "h23");
1343                    }
1344                    Asel::H30 => {
1345                        push_directive(tokens, "h30");
1346                    }
1347                    Asel::H31 => {
1348                        push_directive(tokens, "h31");
1349                    }
1350                    Asel::H32 => {
1351                        push_directive(tokens, "h32");
1352                    }
1353                    Asel::H33 => {
1354                        push_directive(tokens, "h33");
1355                    }
1356                }
1357            }
1358            tokens.push(PtxToken::Comma);
1359            if spaced {
1360                tokens.push(PtxToken::Space);
1361            }
1362            self.b.unparse_tokens_mode(tokens, spaced);
1363            if let Some(bsel_23) = self.bsel.as_ref() {
1364                match bsel_23 {
1365                    Bsel::H00 => {
1366                        push_directive(tokens, "h00");
1367                    }
1368                    Bsel::H01 => {
1369                        push_directive(tokens, "h01");
1370                    }
1371                    Bsel::H02 => {
1372                        push_directive(tokens, "h02");
1373                    }
1374                    Bsel::H03 => {
1375                        push_directive(tokens, "h03");
1376                    }
1377                    Bsel::H10 => {
1378                        push_directive(tokens, "h10");
1379                    }
1380                    Bsel::H11 => {
1381                        push_directive(tokens, "h11");
1382                    }
1383                    Bsel::H12 => {
1384                        push_directive(tokens, "h12");
1385                    }
1386                    Bsel::H13 => {
1387                        push_directive(tokens, "h13");
1388                    }
1389                    Bsel::H20 => {
1390                        push_directive(tokens, "h20");
1391                    }
1392                    Bsel::H21 => {
1393                        push_directive(tokens, "h21");
1394                    }
1395                    Bsel::H22 => {
1396                        push_directive(tokens, "h22");
1397                    }
1398                    Bsel::H23 => {
1399                        push_directive(tokens, "h23");
1400                    }
1401                    Bsel::H30 => {
1402                        push_directive(tokens, "h30");
1403                    }
1404                    Bsel::H31 => {
1405                        push_directive(tokens, "h31");
1406                    }
1407                    Bsel::H32 => {
1408                        push_directive(tokens, "h32");
1409                    }
1410                    Bsel::H33 => {
1411                        push_directive(tokens, "h33");
1412                    }
1413                }
1414            }
1415            tokens.push(PtxToken::Comma);
1416            if spaced {
1417                tokens.push(PtxToken::Space);
1418            }
1419            self.c.unparse_tokens_mode(tokens, spaced);
1420            tokens.push(PtxToken::Semicolon);
1421            if spaced {
1422                tokens.push(PtxToken::Newline);
1423            }
1424        }
1425    }
1426
1427    impl PtxUnparser for Vavrg2DtypeAtypeBtypeAdd {
1428        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1429            self.unparse_tokens_mode(tokens, false);
1430        }
1431        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1432            push_opcode(tokens, "vavrg2");
1433            match &self.dtype {
1434                Dtype::U32 => {
1435                    push_directive(tokens, "u32");
1436                }
1437                Dtype::S32 => {
1438                    push_directive(tokens, "s32");
1439                }
1440            }
1441            match &self.atype {
1442                Atype::U32 => {
1443                    push_directive(tokens, "u32");
1444                }
1445                Atype::S32 => {
1446                    push_directive(tokens, "s32");
1447                }
1448            }
1449            match &self.btype {
1450                Btype::U32 => {
1451                    push_directive(tokens, "u32");
1452                }
1453                Btype::S32 => {
1454                    push_directive(tokens, "s32");
1455                }
1456            }
1457            push_directive(tokens, "add");
1458            if spaced {
1459                tokens.push(PtxToken::Space);
1460            }
1461            self.d.unparse_tokens_mode(tokens, spaced);
1462            if let Some(mask_24) = self.mask.as_ref() {
1463                match mask_24 {
1464                    Mask::H10 => {
1465                        push_directive(tokens, "h10");
1466                    }
1467                    Mask::H0 => {
1468                        push_directive(tokens, "h0");
1469                    }
1470                    Mask::H1 => {
1471                        push_directive(tokens, "h1");
1472                    }
1473                }
1474            }
1475            tokens.push(PtxToken::Comma);
1476            if spaced {
1477                tokens.push(PtxToken::Space);
1478            }
1479            self.a.unparse_tokens_mode(tokens, spaced);
1480            if let Some(asel_25) = self.asel.as_ref() {
1481                match asel_25 {
1482                    Asel::H00 => {
1483                        push_directive(tokens, "h00");
1484                    }
1485                    Asel::H01 => {
1486                        push_directive(tokens, "h01");
1487                    }
1488                    Asel::H02 => {
1489                        push_directive(tokens, "h02");
1490                    }
1491                    Asel::H03 => {
1492                        push_directive(tokens, "h03");
1493                    }
1494                    Asel::H10 => {
1495                        push_directive(tokens, "h10");
1496                    }
1497                    Asel::H11 => {
1498                        push_directive(tokens, "h11");
1499                    }
1500                    Asel::H12 => {
1501                        push_directive(tokens, "h12");
1502                    }
1503                    Asel::H13 => {
1504                        push_directive(tokens, "h13");
1505                    }
1506                    Asel::H20 => {
1507                        push_directive(tokens, "h20");
1508                    }
1509                    Asel::H21 => {
1510                        push_directive(tokens, "h21");
1511                    }
1512                    Asel::H22 => {
1513                        push_directive(tokens, "h22");
1514                    }
1515                    Asel::H23 => {
1516                        push_directive(tokens, "h23");
1517                    }
1518                    Asel::H30 => {
1519                        push_directive(tokens, "h30");
1520                    }
1521                    Asel::H31 => {
1522                        push_directive(tokens, "h31");
1523                    }
1524                    Asel::H32 => {
1525                        push_directive(tokens, "h32");
1526                    }
1527                    Asel::H33 => {
1528                        push_directive(tokens, "h33");
1529                    }
1530                }
1531            }
1532            tokens.push(PtxToken::Comma);
1533            if spaced {
1534                tokens.push(PtxToken::Space);
1535            }
1536            self.b.unparse_tokens_mode(tokens, spaced);
1537            if let Some(bsel_26) = self.bsel.as_ref() {
1538                match bsel_26 {
1539                    Bsel::H00 => {
1540                        push_directive(tokens, "h00");
1541                    }
1542                    Bsel::H01 => {
1543                        push_directive(tokens, "h01");
1544                    }
1545                    Bsel::H02 => {
1546                        push_directive(tokens, "h02");
1547                    }
1548                    Bsel::H03 => {
1549                        push_directive(tokens, "h03");
1550                    }
1551                    Bsel::H10 => {
1552                        push_directive(tokens, "h10");
1553                    }
1554                    Bsel::H11 => {
1555                        push_directive(tokens, "h11");
1556                    }
1557                    Bsel::H12 => {
1558                        push_directive(tokens, "h12");
1559                    }
1560                    Bsel::H13 => {
1561                        push_directive(tokens, "h13");
1562                    }
1563                    Bsel::H20 => {
1564                        push_directive(tokens, "h20");
1565                    }
1566                    Bsel::H21 => {
1567                        push_directive(tokens, "h21");
1568                    }
1569                    Bsel::H22 => {
1570                        push_directive(tokens, "h22");
1571                    }
1572                    Bsel::H23 => {
1573                        push_directive(tokens, "h23");
1574                    }
1575                    Bsel::H30 => {
1576                        push_directive(tokens, "h30");
1577                    }
1578                    Bsel::H31 => {
1579                        push_directive(tokens, "h31");
1580                    }
1581                    Bsel::H32 => {
1582                        push_directive(tokens, "h32");
1583                    }
1584                    Bsel::H33 => {
1585                        push_directive(tokens, "h33");
1586                    }
1587                }
1588            }
1589            tokens.push(PtxToken::Comma);
1590            if spaced {
1591                tokens.push(PtxToken::Space);
1592            }
1593            self.c.unparse_tokens_mode(tokens, spaced);
1594            tokens.push(PtxToken::Semicolon);
1595            if spaced {
1596                tokens.push(PtxToken::Newline);
1597            }
1598        }
1599    }
1600
1601    impl PtxUnparser for Vabsdiff2DtypeAtypeBtypeAdd {
1602        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1603            self.unparse_tokens_mode(tokens, false);
1604        }
1605        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1606            push_opcode(tokens, "vabsdiff2");
1607            match &self.dtype {
1608                Dtype::U32 => {
1609                    push_directive(tokens, "u32");
1610                }
1611                Dtype::S32 => {
1612                    push_directive(tokens, "s32");
1613                }
1614            }
1615            match &self.atype {
1616                Atype::U32 => {
1617                    push_directive(tokens, "u32");
1618                }
1619                Atype::S32 => {
1620                    push_directive(tokens, "s32");
1621                }
1622            }
1623            match &self.btype {
1624                Btype::U32 => {
1625                    push_directive(tokens, "u32");
1626                }
1627                Btype::S32 => {
1628                    push_directive(tokens, "s32");
1629                }
1630            }
1631            push_directive(tokens, "add");
1632            if spaced {
1633                tokens.push(PtxToken::Space);
1634            }
1635            self.d.unparse_tokens_mode(tokens, spaced);
1636            if let Some(mask_27) = self.mask.as_ref() {
1637                match mask_27 {
1638                    Mask::H10 => {
1639                        push_directive(tokens, "h10");
1640                    }
1641                    Mask::H0 => {
1642                        push_directive(tokens, "h0");
1643                    }
1644                    Mask::H1 => {
1645                        push_directive(tokens, "h1");
1646                    }
1647                }
1648            }
1649            tokens.push(PtxToken::Comma);
1650            if spaced {
1651                tokens.push(PtxToken::Space);
1652            }
1653            self.a.unparse_tokens_mode(tokens, spaced);
1654            if let Some(asel_28) = self.asel.as_ref() {
1655                match asel_28 {
1656                    Asel::H00 => {
1657                        push_directive(tokens, "h00");
1658                    }
1659                    Asel::H01 => {
1660                        push_directive(tokens, "h01");
1661                    }
1662                    Asel::H02 => {
1663                        push_directive(tokens, "h02");
1664                    }
1665                    Asel::H03 => {
1666                        push_directive(tokens, "h03");
1667                    }
1668                    Asel::H10 => {
1669                        push_directive(tokens, "h10");
1670                    }
1671                    Asel::H11 => {
1672                        push_directive(tokens, "h11");
1673                    }
1674                    Asel::H12 => {
1675                        push_directive(tokens, "h12");
1676                    }
1677                    Asel::H13 => {
1678                        push_directive(tokens, "h13");
1679                    }
1680                    Asel::H20 => {
1681                        push_directive(tokens, "h20");
1682                    }
1683                    Asel::H21 => {
1684                        push_directive(tokens, "h21");
1685                    }
1686                    Asel::H22 => {
1687                        push_directive(tokens, "h22");
1688                    }
1689                    Asel::H23 => {
1690                        push_directive(tokens, "h23");
1691                    }
1692                    Asel::H30 => {
1693                        push_directive(tokens, "h30");
1694                    }
1695                    Asel::H31 => {
1696                        push_directive(tokens, "h31");
1697                    }
1698                    Asel::H32 => {
1699                        push_directive(tokens, "h32");
1700                    }
1701                    Asel::H33 => {
1702                        push_directive(tokens, "h33");
1703                    }
1704                }
1705            }
1706            tokens.push(PtxToken::Comma);
1707            if spaced {
1708                tokens.push(PtxToken::Space);
1709            }
1710            self.b.unparse_tokens_mode(tokens, spaced);
1711            if let Some(bsel_29) = self.bsel.as_ref() {
1712                match bsel_29 {
1713                    Bsel::H00 => {
1714                        push_directive(tokens, "h00");
1715                    }
1716                    Bsel::H01 => {
1717                        push_directive(tokens, "h01");
1718                    }
1719                    Bsel::H02 => {
1720                        push_directive(tokens, "h02");
1721                    }
1722                    Bsel::H03 => {
1723                        push_directive(tokens, "h03");
1724                    }
1725                    Bsel::H10 => {
1726                        push_directive(tokens, "h10");
1727                    }
1728                    Bsel::H11 => {
1729                        push_directive(tokens, "h11");
1730                    }
1731                    Bsel::H12 => {
1732                        push_directive(tokens, "h12");
1733                    }
1734                    Bsel::H13 => {
1735                        push_directive(tokens, "h13");
1736                    }
1737                    Bsel::H20 => {
1738                        push_directive(tokens, "h20");
1739                    }
1740                    Bsel::H21 => {
1741                        push_directive(tokens, "h21");
1742                    }
1743                    Bsel::H22 => {
1744                        push_directive(tokens, "h22");
1745                    }
1746                    Bsel::H23 => {
1747                        push_directive(tokens, "h23");
1748                    }
1749                    Bsel::H30 => {
1750                        push_directive(tokens, "h30");
1751                    }
1752                    Bsel::H31 => {
1753                        push_directive(tokens, "h31");
1754                    }
1755                    Bsel::H32 => {
1756                        push_directive(tokens, "h32");
1757                    }
1758                    Bsel::H33 => {
1759                        push_directive(tokens, "h33");
1760                    }
1761                }
1762            }
1763            tokens.push(PtxToken::Comma);
1764            if spaced {
1765                tokens.push(PtxToken::Space);
1766            }
1767            self.c.unparse_tokens_mode(tokens, spaced);
1768            tokens.push(PtxToken::Semicolon);
1769            if spaced {
1770                tokens.push(PtxToken::Newline);
1771            }
1772        }
1773    }
1774
1775    impl PtxUnparser for Vmin2DtypeAtypeBtypeAdd {
1776        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1777            self.unparse_tokens_mode(tokens, false);
1778        }
1779        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1780            push_opcode(tokens, "vmin2");
1781            match &self.dtype {
1782                Dtype::U32 => {
1783                    push_directive(tokens, "u32");
1784                }
1785                Dtype::S32 => {
1786                    push_directive(tokens, "s32");
1787                }
1788            }
1789            match &self.atype {
1790                Atype::U32 => {
1791                    push_directive(tokens, "u32");
1792                }
1793                Atype::S32 => {
1794                    push_directive(tokens, "s32");
1795                }
1796            }
1797            match &self.btype {
1798                Btype::U32 => {
1799                    push_directive(tokens, "u32");
1800                }
1801                Btype::S32 => {
1802                    push_directive(tokens, "s32");
1803                }
1804            }
1805            push_directive(tokens, "add");
1806            if spaced {
1807                tokens.push(PtxToken::Space);
1808            }
1809            self.d.unparse_tokens_mode(tokens, spaced);
1810            if let Some(mask_30) = self.mask.as_ref() {
1811                match mask_30 {
1812                    Mask::H10 => {
1813                        push_directive(tokens, "h10");
1814                    }
1815                    Mask::H0 => {
1816                        push_directive(tokens, "h0");
1817                    }
1818                    Mask::H1 => {
1819                        push_directive(tokens, "h1");
1820                    }
1821                }
1822            }
1823            tokens.push(PtxToken::Comma);
1824            if spaced {
1825                tokens.push(PtxToken::Space);
1826            }
1827            self.a.unparse_tokens_mode(tokens, spaced);
1828            if let Some(asel_31) = self.asel.as_ref() {
1829                match asel_31 {
1830                    Asel::H00 => {
1831                        push_directive(tokens, "h00");
1832                    }
1833                    Asel::H01 => {
1834                        push_directive(tokens, "h01");
1835                    }
1836                    Asel::H02 => {
1837                        push_directive(tokens, "h02");
1838                    }
1839                    Asel::H03 => {
1840                        push_directive(tokens, "h03");
1841                    }
1842                    Asel::H10 => {
1843                        push_directive(tokens, "h10");
1844                    }
1845                    Asel::H11 => {
1846                        push_directive(tokens, "h11");
1847                    }
1848                    Asel::H12 => {
1849                        push_directive(tokens, "h12");
1850                    }
1851                    Asel::H13 => {
1852                        push_directive(tokens, "h13");
1853                    }
1854                    Asel::H20 => {
1855                        push_directive(tokens, "h20");
1856                    }
1857                    Asel::H21 => {
1858                        push_directive(tokens, "h21");
1859                    }
1860                    Asel::H22 => {
1861                        push_directive(tokens, "h22");
1862                    }
1863                    Asel::H23 => {
1864                        push_directive(tokens, "h23");
1865                    }
1866                    Asel::H30 => {
1867                        push_directive(tokens, "h30");
1868                    }
1869                    Asel::H31 => {
1870                        push_directive(tokens, "h31");
1871                    }
1872                    Asel::H32 => {
1873                        push_directive(tokens, "h32");
1874                    }
1875                    Asel::H33 => {
1876                        push_directive(tokens, "h33");
1877                    }
1878                }
1879            }
1880            tokens.push(PtxToken::Comma);
1881            if spaced {
1882                tokens.push(PtxToken::Space);
1883            }
1884            self.b.unparse_tokens_mode(tokens, spaced);
1885            if let Some(bsel_32) = self.bsel.as_ref() {
1886                match bsel_32 {
1887                    Bsel::H00 => {
1888                        push_directive(tokens, "h00");
1889                    }
1890                    Bsel::H01 => {
1891                        push_directive(tokens, "h01");
1892                    }
1893                    Bsel::H02 => {
1894                        push_directive(tokens, "h02");
1895                    }
1896                    Bsel::H03 => {
1897                        push_directive(tokens, "h03");
1898                    }
1899                    Bsel::H10 => {
1900                        push_directive(tokens, "h10");
1901                    }
1902                    Bsel::H11 => {
1903                        push_directive(tokens, "h11");
1904                    }
1905                    Bsel::H12 => {
1906                        push_directive(tokens, "h12");
1907                    }
1908                    Bsel::H13 => {
1909                        push_directive(tokens, "h13");
1910                    }
1911                    Bsel::H20 => {
1912                        push_directive(tokens, "h20");
1913                    }
1914                    Bsel::H21 => {
1915                        push_directive(tokens, "h21");
1916                    }
1917                    Bsel::H22 => {
1918                        push_directive(tokens, "h22");
1919                    }
1920                    Bsel::H23 => {
1921                        push_directive(tokens, "h23");
1922                    }
1923                    Bsel::H30 => {
1924                        push_directive(tokens, "h30");
1925                    }
1926                    Bsel::H31 => {
1927                        push_directive(tokens, "h31");
1928                    }
1929                    Bsel::H32 => {
1930                        push_directive(tokens, "h32");
1931                    }
1932                    Bsel::H33 => {
1933                        push_directive(tokens, "h33");
1934                    }
1935                }
1936            }
1937            tokens.push(PtxToken::Comma);
1938            if spaced {
1939                tokens.push(PtxToken::Space);
1940            }
1941            self.c.unparse_tokens_mode(tokens, spaced);
1942            tokens.push(PtxToken::Semicolon);
1943            if spaced {
1944                tokens.push(PtxToken::Newline);
1945            }
1946        }
1947    }
1948
1949    impl PtxUnparser for Vmax2DtypeAtypeBtypeAdd {
1950        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1951            self.unparse_tokens_mode(tokens, false);
1952        }
1953        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1954            push_opcode(tokens, "vmax2");
1955            match &self.dtype {
1956                Dtype::U32 => {
1957                    push_directive(tokens, "u32");
1958                }
1959                Dtype::S32 => {
1960                    push_directive(tokens, "s32");
1961                }
1962            }
1963            match &self.atype {
1964                Atype::U32 => {
1965                    push_directive(tokens, "u32");
1966                }
1967                Atype::S32 => {
1968                    push_directive(tokens, "s32");
1969                }
1970            }
1971            match &self.btype {
1972                Btype::U32 => {
1973                    push_directive(tokens, "u32");
1974                }
1975                Btype::S32 => {
1976                    push_directive(tokens, "s32");
1977                }
1978            }
1979            push_directive(tokens, "add");
1980            if spaced {
1981                tokens.push(PtxToken::Space);
1982            }
1983            self.d.unparse_tokens_mode(tokens, spaced);
1984            if let Some(mask_33) = self.mask.as_ref() {
1985                match mask_33 {
1986                    Mask::H10 => {
1987                        push_directive(tokens, "h10");
1988                    }
1989                    Mask::H0 => {
1990                        push_directive(tokens, "h0");
1991                    }
1992                    Mask::H1 => {
1993                        push_directive(tokens, "h1");
1994                    }
1995                }
1996            }
1997            tokens.push(PtxToken::Comma);
1998            if spaced {
1999                tokens.push(PtxToken::Space);
2000            }
2001            self.a.unparse_tokens_mode(tokens, spaced);
2002            if let Some(asel_34) = self.asel.as_ref() {
2003                match asel_34 {
2004                    Asel::H00 => {
2005                        push_directive(tokens, "h00");
2006                    }
2007                    Asel::H01 => {
2008                        push_directive(tokens, "h01");
2009                    }
2010                    Asel::H02 => {
2011                        push_directive(tokens, "h02");
2012                    }
2013                    Asel::H03 => {
2014                        push_directive(tokens, "h03");
2015                    }
2016                    Asel::H10 => {
2017                        push_directive(tokens, "h10");
2018                    }
2019                    Asel::H11 => {
2020                        push_directive(tokens, "h11");
2021                    }
2022                    Asel::H12 => {
2023                        push_directive(tokens, "h12");
2024                    }
2025                    Asel::H13 => {
2026                        push_directive(tokens, "h13");
2027                    }
2028                    Asel::H20 => {
2029                        push_directive(tokens, "h20");
2030                    }
2031                    Asel::H21 => {
2032                        push_directive(tokens, "h21");
2033                    }
2034                    Asel::H22 => {
2035                        push_directive(tokens, "h22");
2036                    }
2037                    Asel::H23 => {
2038                        push_directive(tokens, "h23");
2039                    }
2040                    Asel::H30 => {
2041                        push_directive(tokens, "h30");
2042                    }
2043                    Asel::H31 => {
2044                        push_directive(tokens, "h31");
2045                    }
2046                    Asel::H32 => {
2047                        push_directive(tokens, "h32");
2048                    }
2049                    Asel::H33 => {
2050                        push_directive(tokens, "h33");
2051                    }
2052                }
2053            }
2054            tokens.push(PtxToken::Comma);
2055            if spaced {
2056                tokens.push(PtxToken::Space);
2057            }
2058            self.b.unparse_tokens_mode(tokens, spaced);
2059            if let Some(bsel_35) = self.bsel.as_ref() {
2060                match bsel_35 {
2061                    Bsel::H00 => {
2062                        push_directive(tokens, "h00");
2063                    }
2064                    Bsel::H01 => {
2065                        push_directive(tokens, "h01");
2066                    }
2067                    Bsel::H02 => {
2068                        push_directive(tokens, "h02");
2069                    }
2070                    Bsel::H03 => {
2071                        push_directive(tokens, "h03");
2072                    }
2073                    Bsel::H10 => {
2074                        push_directive(tokens, "h10");
2075                    }
2076                    Bsel::H11 => {
2077                        push_directive(tokens, "h11");
2078                    }
2079                    Bsel::H12 => {
2080                        push_directive(tokens, "h12");
2081                    }
2082                    Bsel::H13 => {
2083                        push_directive(tokens, "h13");
2084                    }
2085                    Bsel::H20 => {
2086                        push_directive(tokens, "h20");
2087                    }
2088                    Bsel::H21 => {
2089                        push_directive(tokens, "h21");
2090                    }
2091                    Bsel::H22 => {
2092                        push_directive(tokens, "h22");
2093                    }
2094                    Bsel::H23 => {
2095                        push_directive(tokens, "h23");
2096                    }
2097                    Bsel::H30 => {
2098                        push_directive(tokens, "h30");
2099                    }
2100                    Bsel::H31 => {
2101                        push_directive(tokens, "h31");
2102                    }
2103                    Bsel::H32 => {
2104                        push_directive(tokens, "h32");
2105                    }
2106                    Bsel::H33 => {
2107                        push_directive(tokens, "h33");
2108                    }
2109                }
2110            }
2111            tokens.push(PtxToken::Comma);
2112            if spaced {
2113                tokens.push(PtxToken::Space);
2114            }
2115            self.c.unparse_tokens_mode(tokens, spaced);
2116            tokens.push(PtxToken::Semicolon);
2117            if spaced {
2118                tokens.push(PtxToken::Newline);
2119            }
2120        }
2121    }
2122}