ptx_parser/unparser/instruction/
vop4.rs

1//! Original PTX specification:
2//!
3//! // SIMD instruction with secondary SIMD merge operation
4//! vop4.dtype.atype.btype{.sat}  d{.mask}, a{.asel}, b{.bsel}, c;
5//! // SIMD instruction with secondary accumulate operation
6//! vop4.dtype.atype.btype.add  d{.mask}, a{.asel}, b{.bsel}, c;
7//! vop4  = { vadd4, vsub4, vavrg4, vabsdiff4, vmin4, vmax4 };
8//! .dtype = .atype = .btype = { .u32, .s32 };
9//! .mask  = { .b0,
10//! .b1, .b10,
11//! .b2, .b20, .b21, .b210,
12//! .b3, .b30, .b31, .b310, .b32, .b320, .b321, .b3210 };
13//! // defaults to .b3210
14//! .asel = .bsel = { .b.n.n.n.n };
15//! .n = { 0, 1, 2, 3, 4, 5, 6, 7};
16//! // .asel defaults to .b3210
17//! // .bsel defaults to .b7654
18
19#![allow(unused)]
20
21use crate::lexer::PtxToken;
22use crate::unparser::{PtxUnparser, common::*};
23
24pub mod section_0 {
25    use super::*;
26    use crate::r#type::instruction::vop4::section_0::*;
27
28    impl PtxUnparser for Vadd4DtypeAtypeBtypeSat {
29        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
30            push_opcode(tokens, "vadd4");
31            match &self.dtype {
32                Dtype::U32 => {
33                    push_directive(tokens, "u32");
34                }
35                Dtype::S32 => {
36                    push_directive(tokens, "s32");
37                }
38            }
39            match &self.atype {
40                Atype::U32 => {
41                    push_directive(tokens, "u32");
42                }
43                Atype::S32 => {
44                    push_directive(tokens, "s32");
45                }
46            }
47            match &self.btype {
48                Btype::U32 => {
49                    push_directive(tokens, "u32");
50                }
51                Btype::S32 => {
52                    push_directive(tokens, "s32");
53                }
54            }
55            if self.sat {
56                push_directive(tokens, "sat");
57            }
58            self.d.unparse_tokens(tokens);
59            if let Some(mask_0) = self.mask.as_ref() {
60                match mask_0 {
61                    Mask::B3210 => {
62                        push_directive(tokens, "b3210");
63                    }
64                    Mask::B210 => {
65                        push_directive(tokens, "b210");
66                    }
67                    Mask::B310 => {
68                        push_directive(tokens, "b310");
69                    }
70                    Mask::B320 => {
71                        push_directive(tokens, "b320");
72                    }
73                    Mask::B321 => {
74                        push_directive(tokens, "b321");
75                    }
76                    Mask::B10 => {
77                        push_directive(tokens, "b10");
78                    }
79                    Mask::B20 => {
80                        push_directive(tokens, "b20");
81                    }
82                    Mask::B21 => {
83                        push_directive(tokens, "b21");
84                    }
85                    Mask::B30 => {
86                        push_directive(tokens, "b30");
87                    }
88                    Mask::B31 => {
89                        push_directive(tokens, "b31");
90                    }
91                    Mask::B32 => {
92                        push_directive(tokens, "b32");
93                    }
94                    Mask::B0 => {
95                        push_directive(tokens, "b0");
96                    }
97                    Mask::B1 => {
98                        push_directive(tokens, "b1");
99                    }
100                    Mask::B2 => {
101                        push_directive(tokens, "b2");
102                    }
103                    Mask::B3 => {
104                        push_directive(tokens, "b3");
105                    }
106                }
107            }
108            tokens.push(PtxToken::Comma);
109            self.a.unparse_tokens(tokens);
110            if let Some(asel_1) = self.asel.as_ref() {
111                match asel_1 {
112                    Asel::BNNNN(_, n1, n2, n3, n4) => {
113                        let mut combined = String::new();
114                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
115                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
116                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
117                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
118                        tokens.push(PtxToken::Dot);
119                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
120                    }
121                }
122            }
123            tokens.push(PtxToken::Comma);
124            self.b.unparse_tokens(tokens);
125            if let Some(bsel_2) = self.bsel.as_ref() {
126                match bsel_2 {
127                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
128                        let mut combined = String::new();
129                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
130                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
131                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
132                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
133                        tokens.push(PtxToken::Dot);
134                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
135                    }
136                }
137            }
138            tokens.push(PtxToken::Comma);
139            self.c.unparse_tokens(tokens);
140            tokens.push(PtxToken::Semicolon);
141        }
142    }
143
144    impl PtxUnparser for Vsub4DtypeAtypeBtypeSat {
145        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
146            push_opcode(tokens, "vsub4");
147            match &self.dtype {
148                Dtype::U32 => {
149                    push_directive(tokens, "u32");
150                }
151                Dtype::S32 => {
152                    push_directive(tokens, "s32");
153                }
154            }
155            match &self.atype {
156                Atype::U32 => {
157                    push_directive(tokens, "u32");
158                }
159                Atype::S32 => {
160                    push_directive(tokens, "s32");
161                }
162            }
163            match &self.btype {
164                Btype::U32 => {
165                    push_directive(tokens, "u32");
166                }
167                Btype::S32 => {
168                    push_directive(tokens, "s32");
169                }
170            }
171            if self.sat {
172                push_directive(tokens, "sat");
173            }
174            self.d.unparse_tokens(tokens);
175            if let Some(mask_3) = self.mask.as_ref() {
176                match mask_3 {
177                    Mask::B3210 => {
178                        push_directive(tokens, "b3210");
179                    }
180                    Mask::B210 => {
181                        push_directive(tokens, "b210");
182                    }
183                    Mask::B310 => {
184                        push_directive(tokens, "b310");
185                    }
186                    Mask::B320 => {
187                        push_directive(tokens, "b320");
188                    }
189                    Mask::B321 => {
190                        push_directive(tokens, "b321");
191                    }
192                    Mask::B10 => {
193                        push_directive(tokens, "b10");
194                    }
195                    Mask::B20 => {
196                        push_directive(tokens, "b20");
197                    }
198                    Mask::B21 => {
199                        push_directive(tokens, "b21");
200                    }
201                    Mask::B30 => {
202                        push_directive(tokens, "b30");
203                    }
204                    Mask::B31 => {
205                        push_directive(tokens, "b31");
206                    }
207                    Mask::B32 => {
208                        push_directive(tokens, "b32");
209                    }
210                    Mask::B0 => {
211                        push_directive(tokens, "b0");
212                    }
213                    Mask::B1 => {
214                        push_directive(tokens, "b1");
215                    }
216                    Mask::B2 => {
217                        push_directive(tokens, "b2");
218                    }
219                    Mask::B3 => {
220                        push_directive(tokens, "b3");
221                    }
222                }
223            }
224            tokens.push(PtxToken::Comma);
225            self.a.unparse_tokens(tokens);
226            if let Some(asel_4) = self.asel.as_ref() {
227                match asel_4 {
228                    Asel::BNNNN(_, n1, n2, n3, n4) => {
229                        let mut combined = String::new();
230                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
231                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
232                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
233                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
234                        tokens.push(PtxToken::Dot);
235                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
236                    }
237                }
238            }
239            tokens.push(PtxToken::Comma);
240            self.b.unparse_tokens(tokens);
241            if let Some(bsel_5) = self.bsel.as_ref() {
242                match bsel_5 {
243                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
244                        let mut combined = String::new();
245                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
246                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
247                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
248                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
249                        tokens.push(PtxToken::Dot);
250                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
251                    }
252                }
253            }
254            tokens.push(PtxToken::Comma);
255            self.c.unparse_tokens(tokens);
256            tokens.push(PtxToken::Semicolon);
257        }
258    }
259
260    impl PtxUnparser for Vavrg4DtypeAtypeBtypeSat {
261        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
262            push_opcode(tokens, "vavrg4");
263            match &self.dtype {
264                Dtype::U32 => {
265                    push_directive(tokens, "u32");
266                }
267                Dtype::S32 => {
268                    push_directive(tokens, "s32");
269                }
270            }
271            match &self.atype {
272                Atype::U32 => {
273                    push_directive(tokens, "u32");
274                }
275                Atype::S32 => {
276                    push_directive(tokens, "s32");
277                }
278            }
279            match &self.btype {
280                Btype::U32 => {
281                    push_directive(tokens, "u32");
282                }
283                Btype::S32 => {
284                    push_directive(tokens, "s32");
285                }
286            }
287            if self.sat {
288                push_directive(tokens, "sat");
289            }
290            self.d.unparse_tokens(tokens);
291            if let Some(mask_6) = self.mask.as_ref() {
292                match mask_6 {
293                    Mask::B3210 => {
294                        push_directive(tokens, "b3210");
295                    }
296                    Mask::B210 => {
297                        push_directive(tokens, "b210");
298                    }
299                    Mask::B310 => {
300                        push_directive(tokens, "b310");
301                    }
302                    Mask::B320 => {
303                        push_directive(tokens, "b320");
304                    }
305                    Mask::B321 => {
306                        push_directive(tokens, "b321");
307                    }
308                    Mask::B10 => {
309                        push_directive(tokens, "b10");
310                    }
311                    Mask::B20 => {
312                        push_directive(tokens, "b20");
313                    }
314                    Mask::B21 => {
315                        push_directive(tokens, "b21");
316                    }
317                    Mask::B30 => {
318                        push_directive(tokens, "b30");
319                    }
320                    Mask::B31 => {
321                        push_directive(tokens, "b31");
322                    }
323                    Mask::B32 => {
324                        push_directive(tokens, "b32");
325                    }
326                    Mask::B0 => {
327                        push_directive(tokens, "b0");
328                    }
329                    Mask::B1 => {
330                        push_directive(tokens, "b1");
331                    }
332                    Mask::B2 => {
333                        push_directive(tokens, "b2");
334                    }
335                    Mask::B3 => {
336                        push_directive(tokens, "b3");
337                    }
338                }
339            }
340            tokens.push(PtxToken::Comma);
341            self.a.unparse_tokens(tokens);
342            if let Some(asel_7) = self.asel.as_ref() {
343                match asel_7 {
344                    Asel::BNNNN(_, n1, n2, n3, n4) => {
345                        let mut combined = String::new();
346                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
347                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
348                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
349                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
350                        tokens.push(PtxToken::Dot);
351                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
352                    }
353                }
354            }
355            tokens.push(PtxToken::Comma);
356            self.b.unparse_tokens(tokens);
357            if let Some(bsel_8) = self.bsel.as_ref() {
358                match bsel_8 {
359                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
360                        let mut combined = String::new();
361                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
362                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
363                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
364                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
365                        tokens.push(PtxToken::Dot);
366                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
367                    }
368                }
369            }
370            tokens.push(PtxToken::Comma);
371            self.c.unparse_tokens(tokens);
372            tokens.push(PtxToken::Semicolon);
373        }
374    }
375
376    impl PtxUnparser for Vabsdiff4DtypeAtypeBtypeSat {
377        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
378            push_opcode(tokens, "vabsdiff4");
379            match &self.dtype {
380                Dtype::U32 => {
381                    push_directive(tokens, "u32");
382                }
383                Dtype::S32 => {
384                    push_directive(tokens, "s32");
385                }
386            }
387            match &self.atype {
388                Atype::U32 => {
389                    push_directive(tokens, "u32");
390                }
391                Atype::S32 => {
392                    push_directive(tokens, "s32");
393                }
394            }
395            match &self.btype {
396                Btype::U32 => {
397                    push_directive(tokens, "u32");
398                }
399                Btype::S32 => {
400                    push_directive(tokens, "s32");
401                }
402            }
403            if self.sat {
404                push_directive(tokens, "sat");
405            }
406            self.d.unparse_tokens(tokens);
407            if let Some(mask_9) = self.mask.as_ref() {
408                match mask_9 {
409                    Mask::B3210 => {
410                        push_directive(tokens, "b3210");
411                    }
412                    Mask::B210 => {
413                        push_directive(tokens, "b210");
414                    }
415                    Mask::B310 => {
416                        push_directive(tokens, "b310");
417                    }
418                    Mask::B320 => {
419                        push_directive(tokens, "b320");
420                    }
421                    Mask::B321 => {
422                        push_directive(tokens, "b321");
423                    }
424                    Mask::B10 => {
425                        push_directive(tokens, "b10");
426                    }
427                    Mask::B20 => {
428                        push_directive(tokens, "b20");
429                    }
430                    Mask::B21 => {
431                        push_directive(tokens, "b21");
432                    }
433                    Mask::B30 => {
434                        push_directive(tokens, "b30");
435                    }
436                    Mask::B31 => {
437                        push_directive(tokens, "b31");
438                    }
439                    Mask::B32 => {
440                        push_directive(tokens, "b32");
441                    }
442                    Mask::B0 => {
443                        push_directive(tokens, "b0");
444                    }
445                    Mask::B1 => {
446                        push_directive(tokens, "b1");
447                    }
448                    Mask::B2 => {
449                        push_directive(tokens, "b2");
450                    }
451                    Mask::B3 => {
452                        push_directive(tokens, "b3");
453                    }
454                }
455            }
456            tokens.push(PtxToken::Comma);
457            self.a.unparse_tokens(tokens);
458            if let Some(asel_10) = self.asel.as_ref() {
459                match asel_10 {
460                    Asel::BNNNN(_, n1, n2, n3, n4) => {
461                        let mut combined = String::new();
462                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
463                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
464                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
465                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
466                        tokens.push(PtxToken::Dot);
467                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
468                    }
469                }
470            }
471            tokens.push(PtxToken::Comma);
472            self.b.unparse_tokens(tokens);
473            if let Some(bsel_11) = self.bsel.as_ref() {
474                match bsel_11 {
475                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
476                        let mut combined = String::new();
477                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
478                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
479                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
480                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
481                        tokens.push(PtxToken::Dot);
482                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
483                    }
484                }
485            }
486            tokens.push(PtxToken::Comma);
487            self.c.unparse_tokens(tokens);
488            tokens.push(PtxToken::Semicolon);
489        }
490    }
491
492    impl PtxUnparser for Vmin4DtypeAtypeBtypeSat {
493        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
494            push_opcode(tokens, "vmin4");
495            match &self.dtype {
496                Dtype::U32 => {
497                    push_directive(tokens, "u32");
498                }
499                Dtype::S32 => {
500                    push_directive(tokens, "s32");
501                }
502            }
503            match &self.atype {
504                Atype::U32 => {
505                    push_directive(tokens, "u32");
506                }
507                Atype::S32 => {
508                    push_directive(tokens, "s32");
509                }
510            }
511            match &self.btype {
512                Btype::U32 => {
513                    push_directive(tokens, "u32");
514                }
515                Btype::S32 => {
516                    push_directive(tokens, "s32");
517                }
518            }
519            if self.sat {
520                push_directive(tokens, "sat");
521            }
522            self.d.unparse_tokens(tokens);
523            if let Some(mask_12) = self.mask.as_ref() {
524                match mask_12 {
525                    Mask::B3210 => {
526                        push_directive(tokens, "b3210");
527                    }
528                    Mask::B210 => {
529                        push_directive(tokens, "b210");
530                    }
531                    Mask::B310 => {
532                        push_directive(tokens, "b310");
533                    }
534                    Mask::B320 => {
535                        push_directive(tokens, "b320");
536                    }
537                    Mask::B321 => {
538                        push_directive(tokens, "b321");
539                    }
540                    Mask::B10 => {
541                        push_directive(tokens, "b10");
542                    }
543                    Mask::B20 => {
544                        push_directive(tokens, "b20");
545                    }
546                    Mask::B21 => {
547                        push_directive(tokens, "b21");
548                    }
549                    Mask::B30 => {
550                        push_directive(tokens, "b30");
551                    }
552                    Mask::B31 => {
553                        push_directive(tokens, "b31");
554                    }
555                    Mask::B32 => {
556                        push_directive(tokens, "b32");
557                    }
558                    Mask::B0 => {
559                        push_directive(tokens, "b0");
560                    }
561                    Mask::B1 => {
562                        push_directive(tokens, "b1");
563                    }
564                    Mask::B2 => {
565                        push_directive(tokens, "b2");
566                    }
567                    Mask::B3 => {
568                        push_directive(tokens, "b3");
569                    }
570                }
571            }
572            tokens.push(PtxToken::Comma);
573            self.a.unparse_tokens(tokens);
574            if let Some(asel_13) = self.asel.as_ref() {
575                match asel_13 {
576                    Asel::BNNNN(_, n1, n2, n3, n4) => {
577                        let mut combined = String::new();
578                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
579                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
580                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
581                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
582                        tokens.push(PtxToken::Dot);
583                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
584                    }
585                }
586            }
587            tokens.push(PtxToken::Comma);
588            self.b.unparse_tokens(tokens);
589            if let Some(bsel_14) = self.bsel.as_ref() {
590                match bsel_14 {
591                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
592                        let mut combined = String::new();
593                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
594                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
595                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
596                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
597                        tokens.push(PtxToken::Dot);
598                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
599                    }
600                }
601            }
602            tokens.push(PtxToken::Comma);
603            self.c.unparse_tokens(tokens);
604            tokens.push(PtxToken::Semicolon);
605        }
606    }
607
608    impl PtxUnparser for Vmax4DtypeAtypeBtypeSat {
609        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
610            push_opcode(tokens, "vmax4");
611            match &self.dtype {
612                Dtype::U32 => {
613                    push_directive(tokens, "u32");
614                }
615                Dtype::S32 => {
616                    push_directive(tokens, "s32");
617                }
618            }
619            match &self.atype {
620                Atype::U32 => {
621                    push_directive(tokens, "u32");
622                }
623                Atype::S32 => {
624                    push_directive(tokens, "s32");
625                }
626            }
627            match &self.btype {
628                Btype::U32 => {
629                    push_directive(tokens, "u32");
630                }
631                Btype::S32 => {
632                    push_directive(tokens, "s32");
633                }
634            }
635            if self.sat {
636                push_directive(tokens, "sat");
637            }
638            self.d.unparse_tokens(tokens);
639            if let Some(mask_15) = self.mask.as_ref() {
640                match mask_15 {
641                    Mask::B3210 => {
642                        push_directive(tokens, "b3210");
643                    }
644                    Mask::B210 => {
645                        push_directive(tokens, "b210");
646                    }
647                    Mask::B310 => {
648                        push_directive(tokens, "b310");
649                    }
650                    Mask::B320 => {
651                        push_directive(tokens, "b320");
652                    }
653                    Mask::B321 => {
654                        push_directive(tokens, "b321");
655                    }
656                    Mask::B10 => {
657                        push_directive(tokens, "b10");
658                    }
659                    Mask::B20 => {
660                        push_directive(tokens, "b20");
661                    }
662                    Mask::B21 => {
663                        push_directive(tokens, "b21");
664                    }
665                    Mask::B30 => {
666                        push_directive(tokens, "b30");
667                    }
668                    Mask::B31 => {
669                        push_directive(tokens, "b31");
670                    }
671                    Mask::B32 => {
672                        push_directive(tokens, "b32");
673                    }
674                    Mask::B0 => {
675                        push_directive(tokens, "b0");
676                    }
677                    Mask::B1 => {
678                        push_directive(tokens, "b1");
679                    }
680                    Mask::B2 => {
681                        push_directive(tokens, "b2");
682                    }
683                    Mask::B3 => {
684                        push_directive(tokens, "b3");
685                    }
686                }
687            }
688            tokens.push(PtxToken::Comma);
689            self.a.unparse_tokens(tokens);
690            if let Some(asel_16) = self.asel.as_ref() {
691                match asel_16 {
692                    Asel::BNNNN(_, n1, n2, n3, n4) => {
693                        let mut combined = String::new();
694                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
695                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
696                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
697                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
698                        tokens.push(PtxToken::Dot);
699                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
700                    }
701                }
702            }
703            tokens.push(PtxToken::Comma);
704            self.b.unparse_tokens(tokens);
705            if let Some(bsel_17) = self.bsel.as_ref() {
706                match bsel_17 {
707                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
708                        let mut combined = String::new();
709                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
710                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
711                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
712                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
713                        tokens.push(PtxToken::Dot);
714                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
715                    }
716                }
717            }
718            tokens.push(PtxToken::Comma);
719            self.c.unparse_tokens(tokens);
720            tokens.push(PtxToken::Semicolon);
721        }
722    }
723
724    impl PtxUnparser for Vadd4DtypeAtypeBtypeAdd {
725        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
726            push_opcode(tokens, "vadd4");
727            match &self.dtype {
728                Dtype::U32 => {
729                    push_directive(tokens, "u32");
730                }
731                Dtype::S32 => {
732                    push_directive(tokens, "s32");
733                }
734            }
735            match &self.atype {
736                Atype::U32 => {
737                    push_directive(tokens, "u32");
738                }
739                Atype::S32 => {
740                    push_directive(tokens, "s32");
741                }
742            }
743            match &self.btype {
744                Btype::U32 => {
745                    push_directive(tokens, "u32");
746                }
747                Btype::S32 => {
748                    push_directive(tokens, "s32");
749                }
750            }
751            push_directive(tokens, "add");
752            self.d.unparse_tokens(tokens);
753            if let Some(mask_18) = self.mask.as_ref() {
754                match mask_18 {
755                    Mask::B3210 => {
756                        push_directive(tokens, "b3210");
757                    }
758                    Mask::B210 => {
759                        push_directive(tokens, "b210");
760                    }
761                    Mask::B310 => {
762                        push_directive(tokens, "b310");
763                    }
764                    Mask::B320 => {
765                        push_directive(tokens, "b320");
766                    }
767                    Mask::B321 => {
768                        push_directive(tokens, "b321");
769                    }
770                    Mask::B10 => {
771                        push_directive(tokens, "b10");
772                    }
773                    Mask::B20 => {
774                        push_directive(tokens, "b20");
775                    }
776                    Mask::B21 => {
777                        push_directive(tokens, "b21");
778                    }
779                    Mask::B30 => {
780                        push_directive(tokens, "b30");
781                    }
782                    Mask::B31 => {
783                        push_directive(tokens, "b31");
784                    }
785                    Mask::B32 => {
786                        push_directive(tokens, "b32");
787                    }
788                    Mask::B0 => {
789                        push_directive(tokens, "b0");
790                    }
791                    Mask::B1 => {
792                        push_directive(tokens, "b1");
793                    }
794                    Mask::B2 => {
795                        push_directive(tokens, "b2");
796                    }
797                    Mask::B3 => {
798                        push_directive(tokens, "b3");
799                    }
800                }
801            }
802            tokens.push(PtxToken::Comma);
803            self.a.unparse_tokens(tokens);
804            if let Some(asel_19) = self.asel.as_ref() {
805                match asel_19 {
806                    Asel::BNNNN(_, n1, n2, n3, n4) => {
807                        let mut combined = String::new();
808                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
809                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
810                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
811                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
812                        tokens.push(PtxToken::Dot);
813                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
814                    }
815                }
816            }
817            tokens.push(PtxToken::Comma);
818            self.b.unparse_tokens(tokens);
819            if let Some(bsel_20) = self.bsel.as_ref() {
820                match bsel_20 {
821                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
822                        let mut combined = String::new();
823                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
824                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
825                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
826                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
827                        tokens.push(PtxToken::Dot);
828                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
829                    }
830                }
831            }
832            tokens.push(PtxToken::Comma);
833            self.c.unparse_tokens(tokens);
834            tokens.push(PtxToken::Semicolon);
835        }
836    }
837
838    impl PtxUnparser for Vsub4DtypeAtypeBtypeAdd {
839        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
840            push_opcode(tokens, "vsub4");
841            match &self.dtype {
842                Dtype::U32 => {
843                    push_directive(tokens, "u32");
844                }
845                Dtype::S32 => {
846                    push_directive(tokens, "s32");
847                }
848            }
849            match &self.atype {
850                Atype::U32 => {
851                    push_directive(tokens, "u32");
852                }
853                Atype::S32 => {
854                    push_directive(tokens, "s32");
855                }
856            }
857            match &self.btype {
858                Btype::U32 => {
859                    push_directive(tokens, "u32");
860                }
861                Btype::S32 => {
862                    push_directive(tokens, "s32");
863                }
864            }
865            push_directive(tokens, "add");
866            self.d.unparse_tokens(tokens);
867            if let Some(mask_21) = self.mask.as_ref() {
868                match mask_21 {
869                    Mask::B3210 => {
870                        push_directive(tokens, "b3210");
871                    }
872                    Mask::B210 => {
873                        push_directive(tokens, "b210");
874                    }
875                    Mask::B310 => {
876                        push_directive(tokens, "b310");
877                    }
878                    Mask::B320 => {
879                        push_directive(tokens, "b320");
880                    }
881                    Mask::B321 => {
882                        push_directive(tokens, "b321");
883                    }
884                    Mask::B10 => {
885                        push_directive(tokens, "b10");
886                    }
887                    Mask::B20 => {
888                        push_directive(tokens, "b20");
889                    }
890                    Mask::B21 => {
891                        push_directive(tokens, "b21");
892                    }
893                    Mask::B30 => {
894                        push_directive(tokens, "b30");
895                    }
896                    Mask::B31 => {
897                        push_directive(tokens, "b31");
898                    }
899                    Mask::B32 => {
900                        push_directive(tokens, "b32");
901                    }
902                    Mask::B0 => {
903                        push_directive(tokens, "b0");
904                    }
905                    Mask::B1 => {
906                        push_directive(tokens, "b1");
907                    }
908                    Mask::B2 => {
909                        push_directive(tokens, "b2");
910                    }
911                    Mask::B3 => {
912                        push_directive(tokens, "b3");
913                    }
914                }
915            }
916            tokens.push(PtxToken::Comma);
917            self.a.unparse_tokens(tokens);
918            if let Some(asel_22) = self.asel.as_ref() {
919                match asel_22 {
920                    Asel::BNNNN(_, n1, n2, n3, n4) => {
921                        let mut combined = String::new();
922                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
923                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
924                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
925                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
926                        tokens.push(PtxToken::Dot);
927                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
928                    }
929                }
930            }
931            tokens.push(PtxToken::Comma);
932            self.b.unparse_tokens(tokens);
933            if let Some(bsel_23) = self.bsel.as_ref() {
934                match bsel_23 {
935                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
936                        let mut combined = String::new();
937                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
938                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
939                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
940                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
941                        tokens.push(PtxToken::Dot);
942                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
943                    }
944                }
945            }
946            tokens.push(PtxToken::Comma);
947            self.c.unparse_tokens(tokens);
948            tokens.push(PtxToken::Semicolon);
949        }
950    }
951
952    impl PtxUnparser for Vavrg4DtypeAtypeBtypeAdd {
953        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
954            push_opcode(tokens, "vavrg4");
955            match &self.dtype {
956                Dtype::U32 => {
957                    push_directive(tokens, "u32");
958                }
959                Dtype::S32 => {
960                    push_directive(tokens, "s32");
961                }
962            }
963            match &self.atype {
964                Atype::U32 => {
965                    push_directive(tokens, "u32");
966                }
967                Atype::S32 => {
968                    push_directive(tokens, "s32");
969                }
970            }
971            match &self.btype {
972                Btype::U32 => {
973                    push_directive(tokens, "u32");
974                }
975                Btype::S32 => {
976                    push_directive(tokens, "s32");
977                }
978            }
979            push_directive(tokens, "add");
980            self.d.unparse_tokens(tokens);
981            if let Some(mask_24) = self.mask.as_ref() {
982                match mask_24 {
983                    Mask::B3210 => {
984                        push_directive(tokens, "b3210");
985                    }
986                    Mask::B210 => {
987                        push_directive(tokens, "b210");
988                    }
989                    Mask::B310 => {
990                        push_directive(tokens, "b310");
991                    }
992                    Mask::B320 => {
993                        push_directive(tokens, "b320");
994                    }
995                    Mask::B321 => {
996                        push_directive(tokens, "b321");
997                    }
998                    Mask::B10 => {
999                        push_directive(tokens, "b10");
1000                    }
1001                    Mask::B20 => {
1002                        push_directive(tokens, "b20");
1003                    }
1004                    Mask::B21 => {
1005                        push_directive(tokens, "b21");
1006                    }
1007                    Mask::B30 => {
1008                        push_directive(tokens, "b30");
1009                    }
1010                    Mask::B31 => {
1011                        push_directive(tokens, "b31");
1012                    }
1013                    Mask::B32 => {
1014                        push_directive(tokens, "b32");
1015                    }
1016                    Mask::B0 => {
1017                        push_directive(tokens, "b0");
1018                    }
1019                    Mask::B1 => {
1020                        push_directive(tokens, "b1");
1021                    }
1022                    Mask::B2 => {
1023                        push_directive(tokens, "b2");
1024                    }
1025                    Mask::B3 => {
1026                        push_directive(tokens, "b3");
1027                    }
1028                }
1029            }
1030            tokens.push(PtxToken::Comma);
1031            self.a.unparse_tokens(tokens);
1032            if let Some(asel_25) = self.asel.as_ref() {
1033                match asel_25 {
1034                    Asel::BNNNN(_, n1, n2, n3, n4) => {
1035                        let mut combined = String::new();
1036                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
1037                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
1038                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
1039                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
1040                        tokens.push(PtxToken::Dot);
1041                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
1042                    }
1043                }
1044            }
1045            tokens.push(PtxToken::Comma);
1046            self.b.unparse_tokens(tokens);
1047            if let Some(bsel_26) = self.bsel.as_ref() {
1048                match bsel_26 {
1049                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
1050                        let mut combined = String::new();
1051                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
1052                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
1053                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
1054                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
1055                        tokens.push(PtxToken::Dot);
1056                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
1057                    }
1058                }
1059            }
1060            tokens.push(PtxToken::Comma);
1061            self.c.unparse_tokens(tokens);
1062            tokens.push(PtxToken::Semicolon);
1063        }
1064    }
1065
1066    impl PtxUnparser for Vabsdiff4DtypeAtypeBtypeAdd {
1067        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1068            push_opcode(tokens, "vabsdiff4");
1069            match &self.dtype {
1070                Dtype::U32 => {
1071                    push_directive(tokens, "u32");
1072                }
1073                Dtype::S32 => {
1074                    push_directive(tokens, "s32");
1075                }
1076            }
1077            match &self.atype {
1078                Atype::U32 => {
1079                    push_directive(tokens, "u32");
1080                }
1081                Atype::S32 => {
1082                    push_directive(tokens, "s32");
1083                }
1084            }
1085            match &self.btype {
1086                Btype::U32 => {
1087                    push_directive(tokens, "u32");
1088                }
1089                Btype::S32 => {
1090                    push_directive(tokens, "s32");
1091                }
1092            }
1093            push_directive(tokens, "add");
1094            self.d.unparse_tokens(tokens);
1095            if let Some(mask_27) = self.mask.as_ref() {
1096                match mask_27 {
1097                    Mask::B3210 => {
1098                        push_directive(tokens, "b3210");
1099                    }
1100                    Mask::B210 => {
1101                        push_directive(tokens, "b210");
1102                    }
1103                    Mask::B310 => {
1104                        push_directive(tokens, "b310");
1105                    }
1106                    Mask::B320 => {
1107                        push_directive(tokens, "b320");
1108                    }
1109                    Mask::B321 => {
1110                        push_directive(tokens, "b321");
1111                    }
1112                    Mask::B10 => {
1113                        push_directive(tokens, "b10");
1114                    }
1115                    Mask::B20 => {
1116                        push_directive(tokens, "b20");
1117                    }
1118                    Mask::B21 => {
1119                        push_directive(tokens, "b21");
1120                    }
1121                    Mask::B30 => {
1122                        push_directive(tokens, "b30");
1123                    }
1124                    Mask::B31 => {
1125                        push_directive(tokens, "b31");
1126                    }
1127                    Mask::B32 => {
1128                        push_directive(tokens, "b32");
1129                    }
1130                    Mask::B0 => {
1131                        push_directive(tokens, "b0");
1132                    }
1133                    Mask::B1 => {
1134                        push_directive(tokens, "b1");
1135                    }
1136                    Mask::B2 => {
1137                        push_directive(tokens, "b2");
1138                    }
1139                    Mask::B3 => {
1140                        push_directive(tokens, "b3");
1141                    }
1142                }
1143            }
1144            tokens.push(PtxToken::Comma);
1145            self.a.unparse_tokens(tokens);
1146            if let Some(asel_28) = self.asel.as_ref() {
1147                match asel_28 {
1148                    Asel::BNNNN(_, n1, n2, n3, n4) => {
1149                        let mut combined = String::new();
1150                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
1151                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
1152                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
1153                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
1154                        tokens.push(PtxToken::Dot);
1155                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
1156                    }
1157                }
1158            }
1159            tokens.push(PtxToken::Comma);
1160            self.b.unparse_tokens(tokens);
1161            if let Some(bsel_29) = self.bsel.as_ref() {
1162                match bsel_29 {
1163                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
1164                        let mut combined = String::new();
1165                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
1166                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
1167                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
1168                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
1169                        tokens.push(PtxToken::Dot);
1170                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
1171                    }
1172                }
1173            }
1174            tokens.push(PtxToken::Comma);
1175            self.c.unparse_tokens(tokens);
1176            tokens.push(PtxToken::Semicolon);
1177        }
1178    }
1179
1180    impl PtxUnparser for Vmin4DtypeAtypeBtypeAdd {
1181        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1182            push_opcode(tokens, "vmin4");
1183            match &self.dtype {
1184                Dtype::U32 => {
1185                    push_directive(tokens, "u32");
1186                }
1187                Dtype::S32 => {
1188                    push_directive(tokens, "s32");
1189                }
1190            }
1191            match &self.atype {
1192                Atype::U32 => {
1193                    push_directive(tokens, "u32");
1194                }
1195                Atype::S32 => {
1196                    push_directive(tokens, "s32");
1197                }
1198            }
1199            match &self.btype {
1200                Btype::U32 => {
1201                    push_directive(tokens, "u32");
1202                }
1203                Btype::S32 => {
1204                    push_directive(tokens, "s32");
1205                }
1206            }
1207            push_directive(tokens, "add");
1208            self.d.unparse_tokens(tokens);
1209            if let Some(mask_30) = self.mask.as_ref() {
1210                match mask_30 {
1211                    Mask::B3210 => {
1212                        push_directive(tokens, "b3210");
1213                    }
1214                    Mask::B210 => {
1215                        push_directive(tokens, "b210");
1216                    }
1217                    Mask::B310 => {
1218                        push_directive(tokens, "b310");
1219                    }
1220                    Mask::B320 => {
1221                        push_directive(tokens, "b320");
1222                    }
1223                    Mask::B321 => {
1224                        push_directive(tokens, "b321");
1225                    }
1226                    Mask::B10 => {
1227                        push_directive(tokens, "b10");
1228                    }
1229                    Mask::B20 => {
1230                        push_directive(tokens, "b20");
1231                    }
1232                    Mask::B21 => {
1233                        push_directive(tokens, "b21");
1234                    }
1235                    Mask::B30 => {
1236                        push_directive(tokens, "b30");
1237                    }
1238                    Mask::B31 => {
1239                        push_directive(tokens, "b31");
1240                    }
1241                    Mask::B32 => {
1242                        push_directive(tokens, "b32");
1243                    }
1244                    Mask::B0 => {
1245                        push_directive(tokens, "b0");
1246                    }
1247                    Mask::B1 => {
1248                        push_directive(tokens, "b1");
1249                    }
1250                    Mask::B2 => {
1251                        push_directive(tokens, "b2");
1252                    }
1253                    Mask::B3 => {
1254                        push_directive(tokens, "b3");
1255                    }
1256                }
1257            }
1258            tokens.push(PtxToken::Comma);
1259            self.a.unparse_tokens(tokens);
1260            if let Some(asel_31) = self.asel.as_ref() {
1261                match asel_31 {
1262                    Asel::BNNNN(_, n1, n2, n3, n4) => {
1263                        let mut combined = String::new();
1264                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
1265                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
1266                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
1267                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
1268                        tokens.push(PtxToken::Dot);
1269                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
1270                    }
1271                }
1272            }
1273            tokens.push(PtxToken::Comma);
1274            self.b.unparse_tokens(tokens);
1275            if let Some(bsel_32) = self.bsel.as_ref() {
1276                match bsel_32 {
1277                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
1278                        let mut combined = String::new();
1279                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
1280                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
1281                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
1282                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
1283                        tokens.push(PtxToken::Dot);
1284                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
1285                    }
1286                }
1287            }
1288            tokens.push(PtxToken::Comma);
1289            self.c.unparse_tokens(tokens);
1290            tokens.push(PtxToken::Semicolon);
1291        }
1292    }
1293
1294    impl PtxUnparser for Vmax4DtypeAtypeBtypeAdd {
1295        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1296            push_opcode(tokens, "vmax4");
1297            match &self.dtype {
1298                Dtype::U32 => {
1299                    push_directive(tokens, "u32");
1300                }
1301                Dtype::S32 => {
1302                    push_directive(tokens, "s32");
1303                }
1304            }
1305            match &self.atype {
1306                Atype::U32 => {
1307                    push_directive(tokens, "u32");
1308                }
1309                Atype::S32 => {
1310                    push_directive(tokens, "s32");
1311                }
1312            }
1313            match &self.btype {
1314                Btype::U32 => {
1315                    push_directive(tokens, "u32");
1316                }
1317                Btype::S32 => {
1318                    push_directive(tokens, "s32");
1319                }
1320            }
1321            push_directive(tokens, "add");
1322            self.d.unparse_tokens(tokens);
1323            if let Some(mask_33) = self.mask.as_ref() {
1324                match mask_33 {
1325                    Mask::B3210 => {
1326                        push_directive(tokens, "b3210");
1327                    }
1328                    Mask::B210 => {
1329                        push_directive(tokens, "b210");
1330                    }
1331                    Mask::B310 => {
1332                        push_directive(tokens, "b310");
1333                    }
1334                    Mask::B320 => {
1335                        push_directive(tokens, "b320");
1336                    }
1337                    Mask::B321 => {
1338                        push_directive(tokens, "b321");
1339                    }
1340                    Mask::B10 => {
1341                        push_directive(tokens, "b10");
1342                    }
1343                    Mask::B20 => {
1344                        push_directive(tokens, "b20");
1345                    }
1346                    Mask::B21 => {
1347                        push_directive(tokens, "b21");
1348                    }
1349                    Mask::B30 => {
1350                        push_directive(tokens, "b30");
1351                    }
1352                    Mask::B31 => {
1353                        push_directive(tokens, "b31");
1354                    }
1355                    Mask::B32 => {
1356                        push_directive(tokens, "b32");
1357                    }
1358                    Mask::B0 => {
1359                        push_directive(tokens, "b0");
1360                    }
1361                    Mask::B1 => {
1362                        push_directive(tokens, "b1");
1363                    }
1364                    Mask::B2 => {
1365                        push_directive(tokens, "b2");
1366                    }
1367                    Mask::B3 => {
1368                        push_directive(tokens, "b3");
1369                    }
1370                }
1371            }
1372            tokens.push(PtxToken::Comma);
1373            self.a.unparse_tokens(tokens);
1374            if let Some(asel_34) = self.asel.as_ref() {
1375                match asel_34 {
1376                    Asel::BNNNN(_, n1, n2, n3, n4) => {
1377                        let mut combined = String::new();
1378                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
1379                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
1380                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
1381                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
1382                        tokens.push(PtxToken::Dot);
1383                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
1384                    }
1385                }
1386            }
1387            tokens.push(PtxToken::Comma);
1388            self.b.unparse_tokens(tokens);
1389            if let Some(bsel_35) = self.bsel.as_ref() {
1390                match bsel_35 {
1391                    Bsel::BNNNN(_, n1, n2, n3, n4) => {
1392                        let mut combined = String::new();
1393                        combined.push_str(format!("{:?}", n1).trim_start_matches('_'));
1394                        combined.push_str(format!("{:?}", n2).trim_start_matches('_'));
1395                        combined.push_str(format!("{:?}", n3).trim_start_matches('_'));
1396                        combined.push_str(format!("{:?}", n4).trim_start_matches('_'));
1397                        tokens.push(PtxToken::Dot);
1398                        tokens.push(PtxToken::Identifier(format!("{}{}", "b", combined).into()));
1399                    }
1400                }
1401            }
1402            tokens.push(PtxToken::Comma);
1403            self.c.unparse_tokens(tokens);
1404            tokens.push(PtxToken::Semicolon);
1405        }
1406    }
1407}
ptx_parser/unparser/instruction/vop4.rs

ptx_parser/unparser/instruction/
vop4.rs
