Lines Matching refs:body
6 ir_factory body(&sig->body, mem_ctx);
16 body.emit(r000E);
18 body.emit(r000F);
20 body.emit(r0010);
22 body.emit(r0011);
23 body.emit(assign(r0011, ir_constant::zero(mem_ctx, glsl_type::uvec2_type), 0x03));
26 body.emit(assign(r0010, add(r0012, body.constant(int(32))), 0x01));
29 ir_expression *const r0014 = equal(swizzle_y(r000D), body.constant(0u));
33 exec_list *const f0013_parent_instructions = body.instructions;
36 body.instructions = &f0013->then_instructions;
39 body.emit(r0017);
40 ir_variable *const r0018 = body.make_temp(glsl_type::int_type, "findMSB_retval");
41 body.emit(assign(r0018, expr(ir_unop_find_msb, swizzle_x(r000D)), 0x01));
43 body.emit(assign(r0010, r0018, 0x01));
45 body.emit(assign(r0017, body.constant(int(31)), 0x01));
49 exec_list *const f0019_parent_instructions = body.instructions;
51 body.instructions = &f0019->body_instructions;
54 ir_expression *const r001B = less(r0017, body.constant(int(1)));
56 exec_list *const f001A_parent_instructions = body.instructions;
59 body.instructions = &f001A->then_instructions;
61 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
64 body.instructions = f001A_parent_instructions;
65 body.emit(f001A);
70 ir_expression *const r001D = sub(body.constant(int(31)), r0017);
76 exec_list *const f001C_parent_instructions = body.instructions;
79 body.instructions = &f001C->then_instructions;
82 body.emit(assign(r000C, sub(swizzle_y(r000C), r0022), 0x02));
84 ir_expression *const r0023 = lshift(body.constant(1u), r0017);
85 body.emit(assign(r0011, bit_or(swizzle_y(r0011), r0023), 0x02));
88 body.instructions = f001C_parent_instructions;
89 body.emit(f001C);
93 body.emit(assign(r0017, add(r0017, body.constant(int(-1))), 0x01));
97 body.instructions = f0019_parent_instructions;
98 body.emit(f0019);
103 exec_list *const f0024_parent_instructions = body.instructions;
106 body.instructions = &f0024->then_instructions;
108 body.emit(assign(r000C, sub(swizzle_y(r000C), swizzle_x(r000D)), 0x02));
110 body.emit(assign(r0011, bit_or(swizzle_y(r0011), body.constant(1u)), 0x02));
113 body.instructions = f0024_parent_instructions;
114 body.emit(f0024);
119 body.instructions = f0013_parent_instructions;
120 body.emit(f0013);
124 ir_variable *const r0026 = body.make_temp(glsl_type::uint64_t_type, "packUint2x32_retval");
125 body.emit(assign(r0026, expr(ir_unop_pack_uint_2x32, r000D), 0x01));
127 body.emit(assign(r000F, expr(ir_unop_pack_uint_2x32, r000C), 0x01));
129 body.emit(assign(r000E, body.constant(int(31)), 0x01));
133 exec_list *const f0027_parent_instructions = body.instructions;
135 body.instructions = &f0027->body_instructions;
138 ir_expression *const r0029 = less(r000E, body.constant(int(1)));
140 exec_list *const f0028_parent_instructions = body.instructions;
143 body.instructions = &f0028->then_instructions;
145 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
148 body.instructions = f0028_parent_instructions;
149 body.emit(f0028);
154 ir_expression *const r002B = sub(body.constant(int(63)), r000E);
160 exec_list *const f002A_parent_instructions = body.instructions;
163 body.instructions = &f002A->then_instructions;
166 body.emit(assign(r000F, sub(r000F, r0030), 0x01));
168 ir_expression *const r0031 = lshift(body.constant(1u), r000E);
169 body.emit(assign(r0011, bit_or(swizzle_x(r0011), r0031), 0x01));
172 body.instructions = f002A_parent_instructions;
173 body.emit(f002A);
177 body.emit(assign(r000E, add(r000E, body.constant(int(-1))), 0x01));
181 body.instructions = f0027_parent_instructions;
182 body.emit(f0027);
187 exec_list *const f0032_parent_instructions = body.instructions;
190 body.instructions = &f0032->then_instructions;
192 body.emit(assign(r000F, sub(r000F, r0026), 0x01));
194 body.emit(assign(r0011, bit_or(swizzle_x(r0011), body.constant(1u)), 0x01));
197 body.instructions = f0032_parent_instructions;
198 body.emit(f0032);
202 ir_variable *const r0034 = body.make_temp(glsl_type::uvec4_type, "vec_ctor");
203 body.emit(assign(r0034, r0011, 0x03));
205 body.emit(assign(r0034, expr(ir_unop_unpack_uint_2x32, r000F), 0x0c));
207 body.emit(ret(r0034));
217 ir_factory body(&sig->body, mem_ctx);
226 ir_variable *const r0037 = body.make_temp(glsl_type::uvec2_type, "n");
227 body.emit(assign(r0037, r0035, 0x03));
230 body.emit(r0038);
232 body.emit(r0039);
234 body.emit(r003A);
236 body.emit(r003B);
237 body.emit(assign(r003B, ir_constant::zero(mem_ctx, glsl_type::uvec2_type), 0x03));
240 body.emit(assign(r003A, add(r003C, body.constant(int(32))), 0x01));
243 ir_expression *const r003E = equal(swizzle_y(r0036), body.constant(0u));
247 exec_list *const f003D_parent_instructions = body.instructions;
250 body.instructions = &f003D->then_instructions;
253 body.emit(r0041);
254 ir_variable *const r0042 = body.make_temp(glsl_type::int_type, "findMSB_retval");
255 body.emit(assign(r0042, expr(ir_unop_find_msb, swizzle_x(r0036)), 0x01));
257 body.emit(assign(r003A, r0042, 0x01));
259 body.emit(assign(r0041, body.constant(int(31)), 0x01));
263 exec_list *const f0043_parent_instructions = body.instructions;
265 body.instructions = &f0043->body_instructions;
268 ir_expression *const r0045 = less(r0041, body.constant(int(1)));
270 exec_list *const f0044_parent_instructions = body.instructions;
273 body.instructions = &f0044->then_instructions;
275 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
278 body.instructions = f0044_parent_instructions;
279 body.emit(f0044);
284 ir_expression *const r0047 = sub(body.constant(int(31)), r0041);
290 exec_list *const f0046_parent_instructions = body.instructions;
293 body.instructions = &f0046->then_instructions;
296 body.emit(assign(r0037, sub(swizzle_y(r0037), r004C), 0x02));
298 ir_expression *const r004D = lshift(body.constant(1u), r0041);
299 body.emit(assign(r003B, bit_or(swizzle_y(r003B), r004D), 0x02));
302 body.instructions = f0046_parent_instructions;
303 body.emit(f0046);
307 body.emit(assign(r0041, add(r0041, body.constant(int(-1))), 0x01));
311 body.instructions = f0043_parent_instructions;
312 body.emit(f0043);
317 exec_list *const f004E_parent_instructions = body.instructions;
320 body.instructions = &f004E->then_instructions;
322 body.emit(assign(r0037, sub(swizzle_y(r0037), swizzle_x(r0036)), 0x02));
324 body.emit(assign(r003B, bit_or(swizzle_y(r003B), body.constant(1u)), 0x02));
327 body.instructions = f004E_parent_instructions;
328 body.emit(f004E);
333 body.instructions = f003D_parent_instructions;
334 body.emit(f003D);
338 ir_variable *const r0050 = body.make_temp(glsl_type::uint64_t_type, "packUint2x32_retval");
339 body.emit(assign(r0050, expr(ir_unop_pack_uint_2x32, r0036), 0x01));
341 body.emit(assign(r0039, expr(ir_unop_pack_uint_2x32, r0037), 0x01));
343 body.emit(assign(r0038, body.constant(int(31)), 0x01));
347 exec_list *const f0051_parent_instructions = body.instructions;
349 body.instructions = &f0051->body_instructions;
352 ir_expression *const r0053 = less(r0038, body.constant(int(1)));
354 exec_list *const f0052_parent_instructions = body.instructions;
357 body.instructions = &f0052->then_instructions;
359 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
362 body.instructions = f0052_parent_instructions;
363 body.emit(f0052);
368 ir_expression *const r0055 = sub(body.constant(int(63)), r0038);
374 exec_list *const f0054_parent_instructions = body.instructions;
377 body.instructions = &f0054->then_instructions;
380 body.emit(assign(r0039, sub(r0039, r005A), 0x01));
382 ir_expression *const r005B = lshift(body.constant(1u), r0038);
383 body.emit(assign(r003B, bit_or(swizzle_x(r003B), r005B), 0x01));
386 body.instructions = f0054_parent_instructions;
387 body.emit(f0054);
391 body.emit(assign(r0038, add(r0038, body.constant(int(-1))), 0x01));
395 body.instructions = f0051_parent_instructions;
396 body.emit(f0051);
401 exec_list *const f005C_parent_instructions = body.instructions;
404 body.instructions = &f005C->then_instructions;
406 body.emit(assign(r0039, sub(r0039, r0050), 0x01));
408 body.emit(assign(r003B, bit_or(swizzle_x(r003B), body.constant(1u)), 0x01));
411 body.instructions = f005C_parent_instructions;
412 body.emit(f005C);
416 body.emit(ret(r003B));
426 ir_factory body(&sig->body, mem_ctx);
436 body.emit(r0060);
437 ir_expression *const r0061 = less(swizzle_y(r005E), body.constant(int(0)));
438 ir_expression *const r0062 = less(swizzle_y(r005F), body.constant(int(0)));
439 body.emit(assign(r0060, nequal(r0061, r0062), 0x01));
441 ir_variable *const r0063 = body.make_temp(glsl_type::uvec2_type, "n");
445 body.emit(assign(r0063, expr(ir_unop_unpack_uint_2x32, r0066), 0x03));
447 ir_variable *const r0067 = body.make_temp(glsl_type::uvec2_type, "d");
451 body.emit(assign(r0067, expr(ir_unop_unpack_uint_2x32, r006A), 0x03));
454 body.emit(r006B);
456 body.emit(r006C);
458 body.emit(r006D);
460 body.emit(r006E);
461 body.emit(assign(r006E, ir_constant::zero(mem_ctx, glsl_type::uvec2_type), 0x03));
464 body.emit(assign(r006D, add(r006F, body.constant(int(32))), 0x01));
467 ir_expression *const r0071 = equal(swizzle_y(r0067), body.constant(0u));
471 exec_list *const f0070_parent_instructions = body.instructions;
474 body.instructions = &f0070->then_instructions;
477 body.emit(r0074);
478 ir_variable *const r0075 = body.make_temp(glsl_type::int_type, "findMSB_retval");
479 body.emit(assign(r0075, expr(ir_unop_find_msb, swizzle_x(r0067)), 0x01));
481 body.emit(assign(r006D, r0075, 0x01));
483 body.emit(assign(r0074, body.constant(int(31)), 0x01));
487 exec_list *const f0076_parent_instructions = body.instructions;
489 body.instructions = &f0076->body_instructions;
492 ir_expression *const r0078 = less(r0074, body.constant(int(1)));
494 exec_list *const f0077_parent_instructions = body.instructions;
497 body.instructions = &f0077->then_instructions;
499 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
502 body.instructions = f0077_parent_instructions;
503 body.emit(f0077);
508 ir_expression *const r007A = sub(body.constant(int(31)), r0074);
514 exec_list *const f0079_parent_instructions = body.instructions;
517 body.instructions = &f0079->then_instructions;
520 body.emit(assign(r0063, sub(swizzle_y(r0063), r007F), 0x02));
522 ir_expression *const r0080 = lshift(body.constant(1u), r0074);
523 body.emit(assign(r006E, bit_or(swizzle_y(r006E), r0080), 0x02));
526 body.instructions = f0079_parent_instructions;
527 body.emit(f0079);
531 body.emit(assign(r0074, add(r0074, body.constant(int(-1))), 0x01));
535 body.instructions = f0076_parent_instructions;
536 body.emit(f0076);
541 exec_list *const f0081_parent_instructions = body.instructions;
544 body.instructions = &f0081->then_instructions;
546 body.emit(assign(r0063, sub(swizzle_y(r0063), swizzle_x(r0067)), 0x02));
548 body.emit(assign(r006E, bit_or(swizzle_y(r006E), body.constant(1u)), 0x02));
551 body.instructions = f0081_parent_instructions;
552 body.emit(f0081);
557 body.instructions = f0070_parent_instructions;
558 body.emit(f0070);
562 ir_variable *const r0083 = body.make_temp(glsl_type::uint64_t_type, "packUint2x32_retval");
563 body.emit(assign(r0083, expr(ir_unop_pack_uint_2x32, r0067), 0x01));
565 body.emit(assign(r006C, expr(ir_unop_pack_uint_2x32, r0063), 0x01));
567 body.emit(assign(r006B, body.constant(int(31)), 0x01));
571 exec_list *const f0084_parent_instructions = body.instructions;
573 body.instructions = &f0084->body_instructions;
576 ir_expression *const r0086 = less(r006B, body.constant(int(1)));
578 exec_list *const f0085_parent_instructions = body.instructions;
581 body.instructions = &f0085->then_instructions;
583 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
586 body.instructions = f0085_parent_instructions;
587 body.emit(f0085);
592 ir_expression *const r0088 = sub(body.constant(int(63)), r006B);
598 exec_list *const f0087_parent_instructions = body.instructions;
601 body.instructions = &f0087->then_instructions;
604 body.emit(assign(r006C, sub(r006C, r008D), 0x01));
606 ir_expression *const r008E = lshift(body.constant(1u), r006B);
607 body.emit(assign(r006E, bit_or(swizzle_x(r006E), r008E), 0x01));
610 body.instructions = f0087_parent_instructions;
611 body.emit(f0087);
615 body.emit(assign(r006B, add(r006B, body.constant(int(-1))), 0x01));
619 body.instructions = f0084_parent_instructions;
620 body.emit(f0084);
625 exec_list *const f008F_parent_instructions = body.instructions;
628 body.instructions = &f008F->then_instructions;
630 body.emit(assign(r006C, sub(r006C, r0083), 0x01));
632 body.emit(assign(r006E, bit_or(swizzle_x(r006E), body.constant(1u)), 0x01));
635 body.instructions = f008F_parent_instructions;
636 body.emit(f008F);
640 ir_variable *const r0091 = body.make_temp(glsl_type::ivec2_type, "conditional_tmp");
643 exec_list *const f0092_parent_instructions = body.instructions;
646 body.instructions = &f0092->then_instructions;
651 body.emit(assign(r0091, expr(ir_unop_unpack_int_2x32, r0095), 0x03));
655 body.instructions = &f0092->else_instructions;
657 body.emit(assign(r0091, expr(ir_unop_u2i, r006E), 0x03));
660 body.instructions = f0092_parent_instructions;
661 body.emit(f0092);
665 body.emit(ret(r0091));
675 ir_factory body(&sig->body, mem_ctx);
684 ir_variable *const r0098 = body.make_temp(glsl_type::uvec2_type, "n");
685 body.emit(assign(r0098, r0096, 0x03));
688 body.emit(r0099);
690 body.emit(r009A);
692 body.emit(r009B);
694 body.emit(r009C);
695 body.emit(assign(r009C, ir_constant::zero(mem_ctx, glsl_type::uvec2_type), 0x03));
698 body.emit(assign(r009B, add(r009D, body.constant(int(32))), 0x01));
701 ir_expression *const r009F = equal(swizzle_y(r0097), body.constant(0u));
705 exec_list *const f009E_parent_instructions = body.instructions;
708 body.instructions = &f009E->then_instructions;
711 body.emit(r00A2);
712 ir_variable *const r00A3 = body.make_temp(glsl_type::int_type, "findMSB_retval");
713 body.emit(assign(r00A3, expr(ir_unop_find_msb, swizzle_x(r0097)), 0x01));
715 body.emit(assign(r009B, r00A3, 0x01));
717 body.emit(assign(r00A2, body.constant(int(31)), 0x01));
721 exec_list *const f00A4_parent_instructions = body.instructions;
723 body.instructions = &f00A4->body_instructions;
726 ir_expression *const r00A6 = less(r00A2, body.constant(int(1)));
728 exec_list *const f00A5_parent_instructions = body.instructions;
731 body.instructions = &f00A5->then_instructions;
733 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
736 body.instructions = f00A5_parent_instructions;
737 body.emit(f00A5);
742 ir_expression *const r00A8 = sub(body.constant(int(31)), r00A2);
748 exec_list *const f00A7_parent_instructions = body.instructions;
751 body.instructions = &f00A7->then_instructions;
754 body.emit(assign(r0098, sub(swizzle_y(r0098), r00AD), 0x02));
756 ir_expression *const r00AE = lshift(body.constant(1u), r00A2);
757 body.emit(assign(r009C, bit_or(swizzle_y(r009C), r00AE), 0x02));
760 body.instructions = f00A7_parent_instructions;
761 body.emit(f00A7);
765 body.emit(assign(r00A2, add(r00A2, body.constant(int(-1))), 0x01));
769 body.instructions = f00A4_parent_instructions;
770 body.emit(f00A4);
775 exec_list *const f00AF_parent_instructions = body.instructions;
778 body.instructions = &f00AF->then_instructions;
780 body.emit(assign(r0098, sub(swizzle_y(r0098), swizzle_x(r0097)), 0x02));
782 body.emit(assign(r009C, bit_or(swizzle_y(r009C), body.constant(1u)), 0x02));
785 body.instructions = f00AF_parent_instructions;
786 body.emit(f00AF);
791 body.instructions = f009E_parent_instructions;
792 body.emit(f009E);
796 ir_variable *const r00B1 = body.make_temp(glsl_type::uint64_t_type, "packUint2x32_retval");
797 body.emit(assign(r00B1, expr(ir_unop_pack_uint_2x32, r0097), 0x01));
799 body.emit(assign(r009A, expr(ir_unop_pack_uint_2x32, r0098), 0x01));
801 body.emit(assign(r0099, body.constant(int(31)), 0x01));
805 exec_list *const f00B2_parent_instructions = body.instructions;
807 body.instructions = &f00B2->body_instructions;
810 ir_expression *const r00B4 = less(r0099, body.constant(int(1)));
812 exec_list *const f00B3_parent_instructions = body.instructions;
815 body.instructions = &f00B3->then_instructions;
817 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
820 body.instructions = f00B3_parent_instructions;
821 body.emit(f00B3);
826 ir_expression *const r00B6 = sub(body.constant(int(63)), r0099);
832 exec_list *const f00B5_parent_instructions = body.instructions;
835 body.instructions = &f00B5->then_instructions;
838 body.emit(assign(r009A, sub(r009A, r00BB), 0x01));
840 ir_expression *const r00BC = lshift(body.constant(1u), r0099);
841 body.emit(assign(r009C, bit_or(swizzle_x(r009C), r00BC), 0x01));
844 body.instructions = f00B5_parent_instructions;
845 body.emit(f00B5);
849 body.emit(assign(r0099, add(r0099, body.constant(int(-1))), 0x01));
853 body.instructions = f00B2_parent_instructions;
854 body.emit(f00B2);
859 exec_list *const f00BD_parent_instructions = body.instructions;
862 body.instructions = &f00BD->then_instructions;
864 body.emit(assign(r009A, sub(r009A, r00B1), 0x01));
866 body.emit(assign(r009C, bit_or(swizzle_x(r009C), body.constant(1u)), 0x01));
869 body.instructions = f00BD_parent_instructions;
870 body.emit(f00BD);
874 ir_variable *const r00BF = body.make_temp(glsl_type::uvec4_type, "vec_ctor");
875 body.emit(assign(r00BF, r009C, 0x03));
877 body.emit(assign(r00BF, expr(ir_unop_unpack_uint_2x32, r009A), 0x0c));
880 body.emit(ret(r00C0));
890 ir_factory body(&sig->body, mem_ctx);
900 body.emit(r00C3);
901 ir_expression *const r00C4 = less(swizzle_y(r00C1), body.constant(int(0)));
902 ir_expression *const r00C5 = less(swizzle_y(r00C2), body.constant(int(0)));
903 body.emit(assign(r00C3, nequal(r00C4, r00C5), 0x01));
905 ir_variable *const r00C6 = body.make_temp(glsl_type::uvec2_type, "n");
909 body.emit(assign(r00C6, expr(ir_unop_unpack_uint_2x32, r00C9), 0x03));
911 ir_variable *const r00CA = body.make_temp(glsl_type::uvec2_type, "d");
915 body.emit(assign(r00CA, expr(ir_unop_unpack_uint_2x32, r00CD), 0x03));
918 body.emit(r00CE);
920 body.emit(r00CF);
922 body.emit(r00D0);
924 body.emit(r00D1);
925 body.emit(assign(r00D1, ir_constant::zero(mem_ctx, glsl_type::uvec2_type), 0x03));
928 body.emit(assign(r00D0, add(r00D2, body.constant(int(32))), 0x01));
931 ir_expression *const r00D4 = equal(swizzle_y(r00CA), body.constant(0u));
935 exec_list *const f00D3_parent_instructions = body.instructions;
938 body.instructions = &f00D3->then_instructions;
941 body.emit(r00D7);
942 ir_variable *const r00D8 = body.make_temp(glsl_type::int_type, "findMSB_retval");
943 body.emit(assign(r00D8, expr(ir_unop_find_msb, swizzle_x(r00CA)), 0x01));
945 body.emit(assign(r00D0, r00D8, 0x01));
947 body.emit(assign(r00D7, body.constant(int(31)), 0x01));
951 exec_list *const f00D9_parent_instructions = body.instructions;
953 body.instructions = &f00D9->body_instructions;
956 ir_expression *const r00DB = less(r00D7, body.constant(int(1)));
958 exec_list *const f00DA_parent_instructions = body.instructions;
961 body.instructions = &f00DA->then_instructions;
963 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
966 body.instructions = f00DA_parent_instructions;
967 body.emit(f00DA);
972 ir_expression *const r00DD = sub(body.constant(int(31)), r00D7);
978 exec_list *const f00DC_parent_instructions = body.instructions;
981 body.instructions = &f00DC->then_instructions;
984 body.emit(assign(r00C6, sub(swizzle_y(r00C6), r00E2), 0x02));
986 ir_expression *const r00E3 = lshift(body.constant(1u), r00D7);
987 body.emit(assign(r00D1, bit_or(swizzle_y(r00D1), r00E3), 0x02));
990 body.instructions = f00DC_parent_instructions;
991 body.emit(f00DC);
995 body.emit(assign(r00D7, add(r00D7, body.constant(int(-1))), 0x01));
999 body.instructions = f00D9_parent_instructions;
1000 body.emit(f00D9);
1005 exec_list *const f00E4_parent_instructions = body.instructions;
1008 body.instructions = &f00E4->then_instructions;
1010 body.emit(assign(r00C6, sub(swizzle_y(r00C6), swizzle_x(r00CA)), 0x02));
1012 body.emit(assign(r00D1, bit_or(swizzle_y(r00D1), body.constant(1u)), 0x02));
1015 body.instructions = f00E4_parent_instructions;
1016 body.emit(f00E4);
1021 body.instructions = f00D3_parent_instructions;
1022 body.emit(f00D3);
1026 ir_variable *const r00E6 = body.make_temp(glsl_type::uint64_t_type, "packUint2x32_retval");
1027 body.emit(assign(r00E6, expr(ir_unop_pack_uint_2x32, r00CA), 0x01));
1029 body.emit(assign(r00CF, expr(ir_unop_pack_uint_2x32, r00C6), 0x01));
1031 body.emit(assign(r00CE, body.constant(int(31)), 0x01));
1035 exec_list *const f00E7_parent_instructions = body.instructions;
1037 body.instructions = &f00E7->body_instructions;
1040 ir_expression *const r00E9 = less(r00CE, body.constant(int(1)));
1042 exec_list *const f00E8_parent_instructions = body.instructions;
1045 body.instructions = &f00E8->then_instructions;
1047 body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
1050 body.instructions = f00E8_parent_instructions;
1051 body.emit(f00E8);
1056 ir_expression *const r00EB = sub(body.constant(int(63)), r00CE);
1062 exec_list *const f00EA_parent_instructions = body.instructions;
1065 body.instructions = &f00EA->then_instructions;
1068 body.emit(assign(r00CF, sub(r00CF, r00F0), 0x01));
1070 ir_expression *const r00F1 = lshift(body.constant(1u), r00CE);
1071 body.emit(assign(r00D1, bit_or(swizzle_x(r00D1), r00F1), 0x01));
1074 body.instructions = f00EA_parent_instructions;
1075 body.emit(f00EA);
1079 body.emit(assign(r00CE, add(r00CE, body.constant(int(-1))), 0x01));
1083 body.instructions = f00E7_parent_instructions;
1084 body.emit(f00E7);
1089 exec_list *const f00F2_parent_instructions = body.instructions;
1092 body.instructions = &f00F2->then_instructions;
1094 body.emit(assign(r00CF, sub(r00CF, r00E6), 0x01));
1096 body.emit(assign(r00D1, bit_or(swizzle_x(r00D1), body.constant(1u)), 0x01));
1099 body.instructions = f00F2_parent_instructions;
1100 body.emit(f00F2);
1104 ir_variable *const r00F4 = body.make_temp(glsl_type::uvec4_type, "vec_ctor");
1105 body.emit(assign(r00F4, r00D1, 0x03));
1107 body.emit(assign(r00F4, expr(ir_unop_unpack_uint_2x32, r00CF), 0x0c));
1109 ir_variable *const r00F5 = body.make_temp(glsl_type::ivec2_type, "conditional_tmp");
1112 exec_list *const f00F6_parent_instructions = body.instructions;
1115 body.instructions = &f00F6->then_instructions;
1121 body.emit(assign(r00F5, expr(ir_unop_unpack_int_2x32, r00FA), 0x03));
1125 body.instructions = &f00F6->else_instructions;
1128 body.emit(assign(r00F5, expr(ir_unop_u2i, r00FB), 0x03));
1131 body.instructions = f00F6_parent_instructions;
1132 body.emit(f00F6);
1136 body.emit(ret(r00F5));