[Mesa-dev] [PATCH 07/50] glsl: Add "built-in" functions to do add(fp64, fp64) (v2)
Dave Airlie
airlied at gmail.com
Tue Mar 13 04:24:32 UTC 2018
From: Elie Tournier <tournier.elie at gmail.com>
v2: use mix and findMSB to optimise.
Signed-off-by: Elie Tournier <elie.tournier at collabora.com>
---
src/compiler/glsl/builtin_float64.h | 3373 +++++++++++++++++++++++++++++++
src/compiler/glsl/builtin_functions.cpp | 4 +
src/compiler/glsl/builtin_functions.h | 3 +
src/compiler/glsl/float64.glsl | 428 ++++
src/compiler/glsl/glcpp/glcpp-parse.y | 1 +
5 files changed, 3809 insertions(+)
diff --git a/src/compiler/glsl/builtin_float64.h b/src/compiler/glsl/builtin_float64.h
index f7e613f..0ebfb42 100644
--- a/src/compiler/glsl/builtin_float64.h
+++ b/src/compiler/glsl/builtin_float64.h
@@ -353,3 +353,3376 @@ flt64(void *mem_ctx, builtin_available_predicate avail)
sig->replace_parameters(&sig_parameters);
return sig;
}
+ir_function_signature *
+add64(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::void_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r007E = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r007E);
+ ir_variable *const r007F = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r007F);
+ ir_variable *const r0080 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b0", ir_var_function_in);
+ sig_parameters.push_tail(r0080);
+ ir_variable *const r0081 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b1", ir_var_function_in);
+ sig_parameters.push_tail(r0081);
+ ir_variable *const r0082 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0082);
+ ir_variable *const r0083 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0083);
+ ir_variable *const r0084 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r0084, add(r007F, r0081), 0x01));
+
+ body.emit(assign(r0083, r0084, 0x01));
+
+ ir_expression *const r0085 = add(r007E, r0080);
+ ir_expression *const r0086 = less(r0084, r007F);
+ ir_expression *const r0087 = expr(ir_unop_b2i, r0086);
+ ir_expression *const r0088 = expr(ir_unop_i2u, r0087);
+ body.emit(assign(r0082, add(r0085, r0088), 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+sub64(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::void_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r0089 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r0089);
+ ir_variable *const r008A = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r008A);
+ ir_variable *const r008B = new(mem_ctx) ir_variable(glsl_type::uint_type, "b0", ir_var_function_in);
+ sig_parameters.push_tail(r008B);
+ ir_variable *const r008C = new(mem_ctx) ir_variable(glsl_type::uint_type, "b1", ir_var_function_in);
+ sig_parameters.push_tail(r008C);
+ ir_variable *const r008D = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r008D);
+ ir_variable *const r008E = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r008E);
+ body.emit(assign(r008E, sub(r008A, r008C), 0x01));
+
+ ir_expression *const r008F = sub(r0089, r008B);
+ ir_expression *const r0090 = less(r008A, r008C);
+ ir_expression *const r0091 = expr(ir_unop_b2i, r0090);
+ ir_expression *const r0092 = expr(ir_unop_i2u, r0091);
+ body.emit(assign(r008D, sub(r008F, r0092), 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+shift64RightJamming(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::void_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r0093 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r0093);
+ ir_variable *const r0094 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r0094);
+ ir_variable *const r0095 = new(mem_ctx) ir_variable(glsl_type::int_type, "count", ir_var_function_in);
+ sig_parameters.push_tail(r0095);
+ ir_variable *const r0096 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0096);
+ ir_variable *const r0097 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0097);
+ ir_variable *const r0098 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0098);
+ ir_variable *const r0099 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r009A = neg(r0095);
+ body.emit(assign(r0099, bit_and(r009A, body.constant(int(31))), 0x01));
+
+ ir_expression *const r009B = bit_or(r0093, r0094);
+ ir_expression *const r009C = nequal(r009B, body.constant(0u));
+ ir_expression *const r009D = expr(ir_unop_b2i, r009C);
+ body.emit(assign(r0098, expr(ir_unop_i2u, r009D), 0x01));
+
+ ir_variable *const r009E = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r009F = equal(r0095, body.constant(int(0)));
+ ir_expression *const r00A0 = less(r0095, body.constant(int(32)));
+ ir_expression *const r00A1 = lshift(r0093, r0099);
+ ir_expression *const r00A2 = rshift(r0094, r0095);
+ ir_expression *const r00A3 = bit_or(r00A1, r00A2);
+ ir_expression *const r00A4 = lshift(r0094, r0099);
+ ir_expression *const r00A5 = nequal(r00A4, body.constant(0u));
+ ir_expression *const r00A6 = expr(ir_unop_b2i, r00A5);
+ ir_expression *const r00A7 = expr(ir_unop_i2u, r00A6);
+ ir_expression *const r00A8 = bit_or(r00A3, r00A7);
+ ir_expression *const r00A9 = equal(r0095, body.constant(int(32)));
+ ir_expression *const r00AA = nequal(r0094, body.constant(0u));
+ ir_expression *const r00AB = expr(ir_unop_b2i, r00AA);
+ ir_expression *const r00AC = expr(ir_unop_i2u, r00AB);
+ ir_expression *const r00AD = bit_or(r0093, r00AC);
+ ir_expression *const r00AE = less(r0095, body.constant(int(64)));
+ ir_expression *const r00AF = bit_and(r0095, body.constant(int(31)));
+ ir_expression *const r00B0 = rshift(r0093, r00AF);
+ ir_expression *const r00B1 = lshift(r0093, r0099);
+ ir_expression *const r00B2 = bit_or(r00B1, r0094);
+ ir_expression *const r00B3 = nequal(r00B2, body.constant(0u));
+ ir_expression *const r00B4 = expr(ir_unop_b2i, r00B3);
+ ir_expression *const r00B5 = expr(ir_unop_i2u, r00B4);
+ ir_expression *const r00B6 = bit_or(r00B0, r00B5);
+ ir_expression *const r00B7 = expr(ir_triop_csel, r00AE, r00B6, r0098);
+ ir_expression *const r00B8 = expr(ir_triop_csel, r00A9, r00AD, r00B7);
+ ir_expression *const r00B9 = expr(ir_triop_csel, r00A0, r00A8, r00B8);
+ body.emit(assign(r009E, expr(ir_triop_csel, r009F, r0094, r00B9), 0x01));
+
+ body.emit(assign(r0098, r009E, 0x01));
+
+ body.emit(assign(r0097, r009E, 0x01));
+
+ ir_expression *const r00BA = less(r0095, body.constant(int(32)));
+ ir_expression *const r00BB = rshift(r0093, r0095);
+ ir_expression *const r00BC = equal(r0095, body.constant(int(0)));
+ ir_expression *const r00BD = expr(ir_triop_csel, r00BC, r0093, body.constant(0u));
+ body.emit(assign(r0096, expr(ir_triop_csel, r00BA, r00BB, r00BD), 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+shift64ExtraRightJamming(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::void_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r00BE = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r00BE);
+ ir_variable *const r00BF = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r00BF);
+ ir_variable *const r00C0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a2", ir_var_function_in);
+ sig_parameters.push_tail(r00C0);
+ ir_variable *const r00C1 = new(mem_ctx) ir_variable(glsl_type::int_type, "count", ir_var_function_in);
+ sig_parameters.push_tail(r00C1);
+ ir_variable *const r00C2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r00C2);
+ ir_variable *const r00C3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r00C3);
+ ir_variable *const r00C4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r00C4);
+ ir_variable *const r00C5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r00C5);
+ ir_variable *const r00C6 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r00C7 = neg(r00C1);
+ body.emit(assign(r00C6, bit_and(r00C7, body.constant(int(31))), 0x01));
+
+ ir_variable *const r00C8 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r00C9 = less(r00C1, body.constant(int(32)));
+ ir_expression *const r00CA = bit_or(r00C0, r00BF);
+ body.emit(assign(r00C8, expr(ir_triop_csel, r00C9, r00C0, r00CA), 0x01));
+
+ body.emit(assign(r00C0, r00C8, 0x01));
+
+ ir_expression *const r00CB = less(r00C1, body.constant(int(32)));
+ ir_expression *const r00CC = lshift(r00BF, r00C6);
+ ir_expression *const r00CD = less(r00C1, body.constant(int(64)));
+ ir_expression *const r00CE = lshift(r00BE, r00C6);
+ ir_expression *const r00CF = equal(r00C1, body.constant(int(64)));
+ ir_expression *const r00D0 = nequal(r00BE, body.constant(0u));
+ ir_expression *const r00D1 = expr(ir_unop_b2i, r00D0);
+ ir_expression *const r00D2 = expr(ir_unop_i2u, r00D1);
+ ir_expression *const r00D3 = expr(ir_triop_csel, r00CF, r00BE, r00D2);
+ ir_expression *const r00D4 = expr(ir_triop_csel, r00CD, r00CE, r00D3);
+ ir_expression *const r00D5 = expr(ir_triop_csel, r00CB, r00CC, r00D4);
+ ir_expression *const r00D6 = nequal(r00C8, body.constant(0u));
+ ir_expression *const r00D7 = expr(ir_unop_b2i, r00D6);
+ ir_expression *const r00D8 = expr(ir_unop_i2u, r00D7);
+ body.emit(assign(r00C5, bit_or(r00D5, r00D8), 0x01));
+
+ ir_variable *const r00D9 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r00DA = equal(r00C1, body.constant(int(0)));
+ ir_expression *const r00DB = equal(r00C1, body.constant(int(32)));
+ ir_expression *const r00DC = expr(ir_triop_csel, r00DB, r00BF, r00C5);
+ body.emit(assign(r00D9, expr(ir_triop_csel, r00DA, r00C8, r00DC), 0x01));
+
+ body.emit(assign(r00C5, r00D9, 0x01));
+
+ body.emit(assign(r00C4, r00D9, 0x01));
+
+ ir_expression *const r00DD = equal(r00C1, body.constant(int(0)));
+ ir_expression *const r00DE = equal(r00C1, body.constant(int(32)));
+ ir_expression *const r00DF = less(r00C1, body.constant(int(32)));
+ ir_expression *const r00E0 = lshift(r00BE, r00C6);
+ ir_expression *const r00E1 = rshift(r00BF, r00C1);
+ ir_expression *const r00E2 = bit_or(r00E0, r00E1);
+ ir_expression *const r00E3 = less(r00C1, body.constant(int(64)));
+ ir_expression *const r00E4 = bit_and(r00C1, body.constant(int(31)));
+ ir_expression *const r00E5 = rshift(r00BE, r00E4);
+ ir_expression *const r00E6 = expr(ir_triop_csel, r00E3, r00E5, body.constant(0u));
+ ir_expression *const r00E7 = expr(ir_triop_csel, r00DF, r00E2, r00E6);
+ ir_expression *const r00E8 = expr(ir_triop_csel, r00DE, r00BE, r00E7);
+ body.emit(assign(r00C3, expr(ir_triop_csel, r00DD, r00BF, r00E8), 0x01));
+
+ ir_expression *const r00E9 = equal(r00C1, body.constant(int(0)));
+ ir_expression *const r00EA = equal(r00C1, body.constant(int(32)));
+ ir_expression *const r00EB = less(r00C1, body.constant(int(32)));
+ ir_expression *const r00EC = rshift(r00BE, r00C1);
+ ir_expression *const r00ED = expr(ir_triop_csel, r00EB, r00EC, body.constant(0u));
+ ir_expression *const r00EE = expr(ir_triop_csel, r00EA, body.constant(0u), r00ED);
+ body.emit(assign(r00C2, expr(ir_triop_csel, r00E9, r00BE, r00EE), 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+shortShift64Left(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::void_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r00EF = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r00EF);
+ ir_variable *const r00F0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r00F0);
+ ir_variable *const r00F1 = new(mem_ctx) ir_variable(glsl_type::int_type, "count", ir_var_function_in);
+ sig_parameters.push_tail(r00F1);
+ ir_variable *const r00F2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r00F2);
+ ir_variable *const r00F3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r00F3);
+ body.emit(assign(r00F3, lshift(r00F0, r00F1), 0x01));
+
+ ir_expression *const r00F4 = equal(r00F1, body.constant(int(0)));
+ ir_expression *const r00F5 = lshift(r00EF, r00F1);
+ ir_expression *const r00F6 = neg(r00F1);
+ ir_expression *const r00F7 = bit_and(r00F6, body.constant(int(31)));
+ ir_expression *const r00F8 = rshift(r00F0, r00F7);
+ ir_expression *const r00F9 = bit_or(r00F5, r00F8);
+ body.emit(assign(r00F2, expr(ir_triop_csel, r00F4, r00EF, r00F9), 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+packFloat64(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::uvec2_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r00FA = new(mem_ctx) ir_variable(glsl_type::uint_type, "zSign", ir_var_function_in);
+ sig_parameters.push_tail(r00FA);
+ ir_variable *const r00FB = new(mem_ctx) ir_variable(glsl_type::int_type, "zExp", ir_var_function_in);
+ sig_parameters.push_tail(r00FB);
+ ir_variable *const r00FC = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac0", ir_var_function_in);
+ sig_parameters.push_tail(r00FC);
+ ir_variable *const r00FD = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac1", ir_var_function_in);
+ sig_parameters.push_tail(r00FD);
+ ir_variable *const r00FE = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r00FE);
+ ir_expression *const r00FF = lshift(r00FA, body.constant(int(31)));
+ ir_expression *const r0100 = expr(ir_unop_i2u, r00FB);
+ ir_expression *const r0101 = lshift(r0100, body.constant(int(20)));
+ ir_expression *const r0102 = add(r00FF, r0101);
+ body.emit(assign(r00FE, add(r0102, r00FC), 0x02));
+
+ body.emit(assign(r00FE, r00FD, 0x01));
+
+ body.emit(ret(r00FE));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+roundAndPackFloat64(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::uvec2_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r0103 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zSign", ir_var_function_in);
+ sig_parameters.push_tail(r0103);
+ ir_variable *const r0104 = new(mem_ctx) ir_variable(glsl_type::int_type, "zExp", ir_var_function_in);
+ sig_parameters.push_tail(r0104);
+ ir_variable *const r0105 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac0", ir_var_function_in);
+ sig_parameters.push_tail(r0105);
+ ir_variable *const r0106 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac1", ir_var_function_in);
+ sig_parameters.push_tail(r0106);
+ ir_variable *const r0107 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac2", ir_var_function_in);
+ sig_parameters.push_tail(r0107);
+ ir_variable *const r0108 = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r0108, body.constant(true), 0x01));
+
+ ir_variable *const r0109 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r010A = new(mem_ctx) ir_variable(glsl_type::bool_type, "increment", ir_var_auto);
+ body.emit(r010A);
+ ir_expression *const r010B = expr(ir_unop_u2i, r0107);
+ body.emit(assign(r010A, less(r010B, body.constant(int(0))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r010D = gequal(r0104, body.constant(int(2045)));
+ ir_if *f010C = new(mem_ctx) ir_if(operand(r010D).val);
+ exec_list *const f010C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f010C->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r010F = less(body.constant(int(2045)), r0104);
+ ir_expression *const r0110 = equal(r0104, body.constant(int(2045)));
+ ir_expression *const r0111 = equal(body.constant(2097151u), r0105);
+ ir_expression *const r0112 = equal(body.constant(4294967295u), r0106);
+ ir_expression *const r0113 = logic_and(r0111, r0112);
+ ir_expression *const r0114 = logic_and(r0110, r0113);
+ ir_expression *const r0115 = logic_and(r0114, r010A);
+ ir_expression *const r0116 = logic_or(r010F, r0115);
+ ir_if *f010E = new(mem_ctx) ir_if(operand(r0116).val);
+ exec_list *const f010E_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f010E->then_instructions;
+
+ ir_variable *const r0117 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0117);
+ ir_expression *const r0118 = lshift(r0103, body.constant(int(31)));
+ body.emit(assign(r0117, add(r0118, body.constant(2146435072u)), 0x02));
+
+ body.emit(assign(r0117, body.constant(0u), 0x01));
+
+ body.emit(assign(r0109, r0117, 0x03));
+
+ body.emit(assign(r0108, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f010E->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r011A = less(r0104, body.constant(int(0)));
+ ir_if *f0119 = new(mem_ctx) ir_if(operand(r011A).val);
+ exec_list *const f0119_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0119->then_instructions;
+
+ ir_variable *const r011B = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r011B, neg(r0104), 0x01));
+
+ ir_variable *const r011C = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ ir_variable *const r011D = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r011D);
+ ir_variable *const r011E = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r011F = neg(r011B);
+ body.emit(assign(r011E, bit_and(r011F, body.constant(int(31))), 0x01));
+
+ ir_variable *const r0120 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0121 = less(r011B, body.constant(int(32)));
+ ir_expression *const r0122 = bit_or(r0107, r0106);
+ body.emit(assign(r0120, expr(ir_triop_csel, r0121, r0107, r0122), 0x01));
+
+ ir_expression *const r0123 = less(r011B, body.constant(int(32)));
+ ir_expression *const r0124 = lshift(r0106, r011E);
+ ir_expression *const r0125 = less(r011B, body.constant(int(64)));
+ ir_expression *const r0126 = lshift(r0105, r011E);
+ ir_expression *const r0127 = equal(r011B, body.constant(int(64)));
+ ir_expression *const r0128 = nequal(r0105, body.constant(0u));
+ ir_expression *const r0129 = expr(ir_unop_b2i, r0128);
+ ir_expression *const r012A = expr(ir_unop_i2u, r0129);
+ ir_expression *const r012B = expr(ir_triop_csel, r0127, r0105, r012A);
+ ir_expression *const r012C = expr(ir_triop_csel, r0125, r0126, r012B);
+ ir_expression *const r012D = expr(ir_triop_csel, r0123, r0124, r012C);
+ ir_expression *const r012E = nequal(r0120, body.constant(0u));
+ ir_expression *const r012F = expr(ir_unop_b2i, r012E);
+ ir_expression *const r0130 = expr(ir_unop_i2u, r012F);
+ body.emit(assign(r011D, bit_or(r012D, r0130), 0x01));
+
+ ir_variable *const r0131 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0132 = equal(r011B, body.constant(int(0)));
+ ir_expression *const r0133 = equal(r011B, body.constant(int(32)));
+ ir_expression *const r0134 = expr(ir_triop_csel, r0133, r0106, r011D);
+ body.emit(assign(r0131, expr(ir_triop_csel, r0132, r0120, r0134), 0x01));
+
+ body.emit(assign(r011D, r0131, 0x01));
+
+ ir_expression *const r0135 = equal(r011B, body.constant(int(0)));
+ ir_expression *const r0136 = equal(r011B, body.constant(int(32)));
+ ir_expression *const r0137 = less(r011B, body.constant(int(32)));
+ ir_expression *const r0138 = lshift(r0105, r011E);
+ ir_expression *const r0139 = rshift(r0106, r011B);
+ ir_expression *const r013A = bit_or(r0138, r0139);
+ ir_expression *const r013B = less(r011B, body.constant(int(64)));
+ ir_expression *const r013C = bit_and(r011B, body.constant(int(31)));
+ ir_expression *const r013D = rshift(r0105, r013C);
+ ir_expression *const r013E = expr(ir_triop_csel, r013B, r013D, body.constant(0u));
+ ir_expression *const r013F = expr(ir_triop_csel, r0137, r013A, r013E);
+ ir_expression *const r0140 = expr(ir_triop_csel, r0136, r0105, r013F);
+ body.emit(assign(r011C, expr(ir_triop_csel, r0135, r0106, r0140), 0x01));
+
+ ir_expression *const r0141 = equal(r011B, body.constant(int(0)));
+ ir_expression *const r0142 = equal(r011B, body.constant(int(32)));
+ ir_expression *const r0143 = less(r011B, body.constant(int(32)));
+ ir_expression *const r0144 = rshift(r0105, r011B);
+ ir_expression *const r0145 = expr(ir_triop_csel, r0143, r0144, body.constant(0u));
+ ir_expression *const r0146 = expr(ir_triop_csel, r0142, body.constant(0u), r0145);
+ body.emit(assign(r0105, expr(ir_triop_csel, r0141, r0105, r0146), 0x01));
+
+ body.emit(assign(r0106, r011C, 0x01));
+
+ body.emit(assign(r0107, r0131, 0x01));
+
+ body.emit(assign(r0104, body.constant(int(0)), 0x01));
+
+ body.emit(assign(r010A, less(r0131, body.constant(0u)), 0x01));
+
+
+ body.instructions = f0119_parent_instructions;
+ body.emit(f0119);
+
+ /* END IF */
+
+
+ body.instructions = f010E_parent_instructions;
+ body.emit(f010E);
+
+ /* END IF */
+
+
+ body.instructions = f010C_parent_instructions;
+ body.emit(f010C);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f0147 = new(mem_ctx) ir_if(operand(r0108).val);
+ exec_list *const f0147_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0147->then_instructions;
+
+ /* IF CONDITION */
+ ir_if *f0148 = new(mem_ctx) ir_if(operand(r010A).val);
+ exec_list *const f0148_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0148->then_instructions;
+
+ ir_variable *const r0149 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r0149, add(r0106, body.constant(1u)), 0x01));
+
+ ir_expression *const r014A = less(r0149, r0106);
+ ir_expression *const r014B = expr(ir_unop_b2i, r014A);
+ ir_expression *const r014C = expr(ir_unop_i2u, r014B);
+ body.emit(assign(r0105, add(r0105, r014C), 0x01));
+
+ ir_expression *const r014D = equal(r0107, body.constant(0u));
+ ir_expression *const r014E = expr(ir_unop_b2i, r014D);
+ ir_expression *const r014F = expr(ir_unop_i2u, r014E);
+ ir_expression *const r0150 = add(r0107, r014F);
+ ir_expression *const r0151 = bit_and(r0150, body.constant(1u));
+ ir_expression *const r0152 = expr(ir_unop_bit_not, r0151);
+ body.emit(assign(r0106, bit_and(r0149, r0152), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0148->else_instructions;
+
+ ir_expression *const r0153 = bit_or(r0105, r0106);
+ ir_expression *const r0154 = equal(r0153, body.constant(0u));
+ body.emit(assign(r0104, expr(ir_triop_csel, r0154, body.constant(int(0)), r0104), 0x01));
+
+
+ body.instructions = f0148_parent_instructions;
+ body.emit(f0148);
+
+ /* END IF */
+
+ ir_variable *const r0155 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0155);
+ ir_expression *const r0156 = lshift(r0103, body.constant(int(31)));
+ ir_expression *const r0157 = expr(ir_unop_i2u, r0104);
+ ir_expression *const r0158 = lshift(r0157, body.constant(int(20)));
+ ir_expression *const r0159 = add(r0156, r0158);
+ body.emit(assign(r0155, add(r0159, r0105), 0x02));
+
+ body.emit(assign(r0155, r0106, 0x01));
+
+ body.emit(assign(r0109, r0155, 0x03));
+
+ body.emit(assign(r0108, body.constant(false), 0x01));
+
+
+ body.instructions = f0147_parent_instructions;
+ body.emit(f0147);
+
+ /* END IF */
+
+ body.emit(ret(r0109));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+countLeadingZeros32(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::int_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r015A = new(mem_ctx) ir_variable(glsl_type::uint_type, "a", ir_var_function_in);
+ sig_parameters.push_tail(r015A);
+ ir_variable *const r015B = body.make_temp(glsl_type::int_type, "mix_retval");
+ ir_expression *const r015C = equal(r015A, body.constant(0u));
+ ir_expression *const r015D = expr(ir_unop_find_msb, r015A);
+ ir_expression *const r015E = sub(body.constant(int(31)), r015D);
+ body.emit(assign(r015B, expr(ir_triop_csel, r015C, body.constant(int(32)), r015E), 0x01));
+
+ body.emit(ret(r015B));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+normalizeRoundAndPackFloat64(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::uvec2_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r015F = new(mem_ctx) ir_variable(glsl_type::uint_type, "zSign", ir_var_function_in);
+ sig_parameters.push_tail(r015F);
+ ir_variable *const r0160 = new(mem_ctx) ir_variable(glsl_type::int_type, "zExp", ir_var_function_in);
+ sig_parameters.push_tail(r0160);
+ ir_variable *const r0161 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac0", ir_var_function_in);
+ sig_parameters.push_tail(r0161);
+ ir_variable *const r0162 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac1", ir_var_function_in);
+ sig_parameters.push_tail(r0162);
+ ir_variable *const r0163 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac2", ir_var_auto);
+ body.emit(r0163);
+ ir_variable *const r0164 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r0164);
+ ir_expression *const r0165 = equal(r0161, body.constant(0u));
+ ir_expression *const r0166 = add(r0160, body.constant(int(-32)));
+ body.emit(assign(r0160, expr(ir_triop_csel, r0165, r0166, r0160), 0x01));
+
+ ir_variable *const r0167 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0168 = equal(r0161, body.constant(0u));
+ body.emit(assign(r0167, expr(ir_triop_csel, r0168, body.constant(0u), r0162), 0x01));
+
+ body.emit(assign(r0162, r0167, 0x01));
+
+ ir_variable *const r0169 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r016A = equal(r0161, body.constant(0u));
+ body.emit(assign(r0169, expr(ir_triop_csel, r016A, r0167, r0161), 0x01));
+
+ body.emit(assign(r0161, r0169, 0x01));
+
+ ir_expression *const r016B = equal(r0169, body.constant(0u));
+ ir_expression *const r016C = expr(ir_unop_find_msb, r0169);
+ ir_expression *const r016D = sub(body.constant(int(31)), r016C);
+ ir_expression *const r016E = expr(ir_triop_csel, r016B, body.constant(int(32)), r016D);
+ body.emit(assign(r0164, add(r016E, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0170 = gequal(r0164, body.constant(int(0)));
+ ir_if *f016F = new(mem_ctx) ir_if(operand(r0170).val);
+ exec_list *const f016F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f016F->then_instructions;
+
+ body.emit(assign(r0163, body.constant(0u), 0x01));
+
+ ir_expression *const r0171 = equal(r0164, body.constant(int(0)));
+ ir_expression *const r0172 = lshift(r0169, r0164);
+ ir_expression *const r0173 = neg(r0164);
+ ir_expression *const r0174 = bit_and(r0173, body.constant(int(31)));
+ ir_expression *const r0175 = rshift(r0167, r0174);
+ ir_expression *const r0176 = bit_or(r0172, r0175);
+ body.emit(assign(r0161, expr(ir_triop_csel, r0171, r0169, r0176), 0x01));
+
+ body.emit(assign(r0162, lshift(r0167, r0164), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f016F->else_instructions;
+
+ ir_variable *const r0177 = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r0177, neg(r0164), 0x01));
+
+ ir_variable *const r0178 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ ir_variable *const r0179 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r0179);
+ ir_variable *const r017A = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r017B = neg(r0177);
+ body.emit(assign(r017A, bit_and(r017B, body.constant(int(31))), 0x01));
+
+ ir_variable *const r017C = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r017D = less(r0177, body.constant(int(32)));
+ ir_expression *const r017E = bit_or(body.constant(0u), r0162);
+ body.emit(assign(r017C, expr(ir_triop_csel, r017D, body.constant(0u), r017E), 0x01));
+
+ ir_expression *const r017F = less(r0177, body.constant(int(32)));
+ ir_expression *const r0180 = lshift(r0162, r017A);
+ ir_expression *const r0181 = less(r0177, body.constant(int(64)));
+ ir_expression *const r0182 = lshift(r0161, r017A);
+ ir_expression *const r0183 = equal(r0177, body.constant(int(64)));
+ ir_expression *const r0184 = nequal(r0161, body.constant(0u));
+ ir_expression *const r0185 = expr(ir_unop_b2i, r0184);
+ ir_expression *const r0186 = expr(ir_unop_i2u, r0185);
+ ir_expression *const r0187 = expr(ir_triop_csel, r0183, r0161, r0186);
+ ir_expression *const r0188 = expr(ir_triop_csel, r0181, r0182, r0187);
+ ir_expression *const r0189 = expr(ir_triop_csel, r017F, r0180, r0188);
+ ir_expression *const r018A = nequal(r017C, body.constant(0u));
+ ir_expression *const r018B = expr(ir_unop_b2i, r018A);
+ ir_expression *const r018C = expr(ir_unop_i2u, r018B);
+ body.emit(assign(r0179, bit_or(r0189, r018C), 0x01));
+
+ ir_variable *const r018D = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r018E = equal(r0177, body.constant(int(0)));
+ ir_expression *const r018F = equal(r0177, body.constant(int(32)));
+ ir_expression *const r0190 = expr(ir_triop_csel, r018F, r0162, r0179);
+ body.emit(assign(r018D, expr(ir_triop_csel, r018E, r017C, r0190), 0x01));
+
+ body.emit(assign(r0179, r018D, 0x01));
+
+ ir_expression *const r0191 = equal(r0177, body.constant(int(0)));
+ ir_expression *const r0192 = equal(r0177, body.constant(int(32)));
+ ir_expression *const r0193 = less(r0177, body.constant(int(32)));
+ ir_expression *const r0194 = lshift(r0161, r017A);
+ ir_expression *const r0195 = rshift(r0162, r0177);
+ ir_expression *const r0196 = bit_or(r0194, r0195);
+ ir_expression *const r0197 = less(r0177, body.constant(int(64)));
+ ir_expression *const r0198 = bit_and(r0177, body.constant(int(31)));
+ ir_expression *const r0199 = rshift(r0161, r0198);
+ ir_expression *const r019A = expr(ir_triop_csel, r0197, r0199, body.constant(0u));
+ ir_expression *const r019B = expr(ir_triop_csel, r0193, r0196, r019A);
+ ir_expression *const r019C = expr(ir_triop_csel, r0192, r0161, r019B);
+ body.emit(assign(r0178, expr(ir_triop_csel, r0191, r0162, r019C), 0x01));
+
+ ir_expression *const r019D = equal(r0177, body.constant(int(0)));
+ ir_expression *const r019E = equal(r0177, body.constant(int(32)));
+ ir_expression *const r019F = less(r0177, body.constant(int(32)));
+ ir_expression *const r01A0 = rshift(r0161, r0177);
+ ir_expression *const r01A1 = expr(ir_triop_csel, r019F, r01A0, body.constant(0u));
+ ir_expression *const r01A2 = expr(ir_triop_csel, r019E, body.constant(0u), r01A1);
+ body.emit(assign(r0161, expr(ir_triop_csel, r019D, r0161, r01A2), 0x01));
+
+ body.emit(assign(r0162, r0178, 0x01));
+
+ body.emit(assign(r0163, r018D, 0x01));
+
+
+ body.instructions = f016F_parent_instructions;
+ body.emit(f016F);
+
+ /* END IF */
+
+ body.emit(assign(r0160, sub(r0160, r0164), 0x01));
+
+ ir_variable *const r01A3 = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r01A3, r0160, 0x01));
+
+ ir_variable *const r01A4 = body.make_temp(glsl_type::uint_type, "zFrac0");
+ body.emit(assign(r01A4, r0161, 0x01));
+
+ ir_variable *const r01A5 = body.make_temp(glsl_type::uint_type, "zFrac1");
+ body.emit(assign(r01A5, r0162, 0x01));
+
+ ir_variable *const r01A6 = body.make_temp(glsl_type::uint_type, "zFrac2");
+ body.emit(assign(r01A6, r0163, 0x01));
+
+ ir_variable *const r01A7 = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r01A7, body.constant(true), 0x01));
+
+ ir_variable *const r01A8 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r01A9 = new(mem_ctx) ir_variable(glsl_type::bool_type, "increment", ir_var_auto);
+ body.emit(r01A9);
+ ir_expression *const r01AA = expr(ir_unop_u2i, r0163);
+ body.emit(assign(r01A9, less(r01AA, body.constant(int(0))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r01AC = gequal(r0160, body.constant(int(2045)));
+ ir_if *f01AB = new(mem_ctx) ir_if(operand(r01AC).val);
+ exec_list *const f01AB_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f01AB->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r01AE = less(body.constant(int(2045)), r0160);
+ ir_expression *const r01AF = equal(r0160, body.constant(int(2045)));
+ ir_expression *const r01B0 = equal(body.constant(2097151u), r0161);
+ ir_expression *const r01B1 = equal(body.constant(4294967295u), r0162);
+ ir_expression *const r01B2 = logic_and(r01B0, r01B1);
+ ir_expression *const r01B3 = logic_and(r01AF, r01B2);
+ ir_expression *const r01B4 = logic_and(r01B3, r01A9);
+ ir_expression *const r01B5 = logic_or(r01AE, r01B4);
+ ir_if *f01AD = new(mem_ctx) ir_if(operand(r01B5).val);
+ exec_list *const f01AD_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f01AD->then_instructions;
+
+ ir_variable *const r01B6 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r01B6);
+ ir_expression *const r01B7 = lshift(r015F, body.constant(int(31)));
+ body.emit(assign(r01B6, add(r01B7, body.constant(2146435072u)), 0x02));
+
+ body.emit(assign(r01B6, body.constant(0u), 0x01));
+
+ body.emit(assign(r01A8, r01B6, 0x03));
+
+ body.emit(assign(r01A7, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f01AD->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r01B9 = less(r0160, body.constant(int(0)));
+ ir_if *f01B8 = new(mem_ctx) ir_if(operand(r01B9).val);
+ exec_list *const f01B8_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f01B8->then_instructions;
+
+ ir_variable *const r01BA = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r01BA, neg(r0160), 0x01));
+
+ ir_variable *const r01BB = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r01BB);
+ ir_variable *const r01BC = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r01BD = neg(r01BA);
+ body.emit(assign(r01BC, bit_and(r01BD, body.constant(int(31))), 0x01));
+
+ ir_variable *const r01BE = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r01BF = less(r01BA, body.constant(int(32)));
+ ir_expression *const r01C0 = bit_or(r0163, r0162);
+ body.emit(assign(r01BE, expr(ir_triop_csel, r01BF, r0163, r01C0), 0x01));
+
+ ir_expression *const r01C1 = less(r01BA, body.constant(int(32)));
+ ir_expression *const r01C2 = lshift(r0162, r01BC);
+ ir_expression *const r01C3 = less(r01BA, body.constant(int(64)));
+ ir_expression *const r01C4 = lshift(r0161, r01BC);
+ ir_expression *const r01C5 = equal(r01BA, body.constant(int(64)));
+ ir_expression *const r01C6 = nequal(r0161, body.constant(0u));
+ ir_expression *const r01C7 = expr(ir_unop_b2i, r01C6);
+ ir_expression *const r01C8 = expr(ir_unop_i2u, r01C7);
+ ir_expression *const r01C9 = expr(ir_triop_csel, r01C5, r0161, r01C8);
+ ir_expression *const r01CA = expr(ir_triop_csel, r01C3, r01C4, r01C9);
+ ir_expression *const r01CB = expr(ir_triop_csel, r01C1, r01C2, r01CA);
+ ir_expression *const r01CC = nequal(r01BE, body.constant(0u));
+ ir_expression *const r01CD = expr(ir_unop_b2i, r01CC);
+ ir_expression *const r01CE = expr(ir_unop_i2u, r01CD);
+ body.emit(assign(r01BB, bit_or(r01CB, r01CE), 0x01));
+
+ ir_variable *const r01CF = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r01D0 = equal(r01BA, body.constant(int(0)));
+ ir_expression *const r01D1 = equal(r01BA, body.constant(int(32)));
+ ir_expression *const r01D2 = expr(ir_triop_csel, r01D1, r0162, r01BB);
+ body.emit(assign(r01CF, expr(ir_triop_csel, r01D0, r01BE, r01D2), 0x01));
+
+ body.emit(assign(r01BB, r01CF, 0x01));
+
+ ir_expression *const r01D3 = equal(r01BA, body.constant(int(0)));
+ ir_expression *const r01D4 = equal(r01BA, body.constant(int(32)));
+ ir_expression *const r01D5 = less(r01BA, body.constant(int(32)));
+ ir_expression *const r01D6 = rshift(r0161, r01BA);
+ ir_expression *const r01D7 = expr(ir_triop_csel, r01D5, r01D6, body.constant(0u));
+ ir_expression *const r01D8 = expr(ir_triop_csel, r01D4, body.constant(0u), r01D7);
+ body.emit(assign(r01A4, expr(ir_triop_csel, r01D3, r0161, r01D8), 0x01));
+
+ ir_expression *const r01D9 = equal(r01BA, body.constant(int(0)));
+ ir_expression *const r01DA = equal(r01BA, body.constant(int(32)));
+ ir_expression *const r01DB = less(r01BA, body.constant(int(32)));
+ ir_expression *const r01DC = lshift(r0161, r01BC);
+ ir_expression *const r01DD = rshift(r0162, r01BA);
+ ir_expression *const r01DE = bit_or(r01DC, r01DD);
+ ir_expression *const r01DF = less(r01BA, body.constant(int(64)));
+ ir_expression *const r01E0 = bit_and(r01BA, body.constant(int(31)));
+ ir_expression *const r01E1 = rshift(r0161, r01E0);
+ ir_expression *const r01E2 = expr(ir_triop_csel, r01DF, r01E1, body.constant(0u));
+ ir_expression *const r01E3 = expr(ir_triop_csel, r01DB, r01DE, r01E2);
+ ir_expression *const r01E4 = expr(ir_triop_csel, r01DA, r0161, r01E3);
+ body.emit(assign(r01A5, expr(ir_triop_csel, r01D9, r0162, r01E4), 0x01));
+
+ body.emit(assign(r01A6, r01CF, 0x01));
+
+ body.emit(assign(r01A3, body.constant(int(0)), 0x01));
+
+ body.emit(assign(r01A9, less(r01CF, body.constant(0u)), 0x01));
+
+
+ body.instructions = f01B8_parent_instructions;
+ body.emit(f01B8);
+
+ /* END IF */
+
+
+ body.instructions = f01AD_parent_instructions;
+ body.emit(f01AD);
+
+ /* END IF */
+
+
+ body.instructions = f01AB_parent_instructions;
+ body.emit(f01AB);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f01E5 = new(mem_ctx) ir_if(operand(r01A7).val);
+ exec_list *const f01E5_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f01E5->then_instructions;
+
+ /* IF CONDITION */
+ ir_if *f01E6 = new(mem_ctx) ir_if(operand(r01A9).val);
+ exec_list *const f01E6_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f01E6->then_instructions;
+
+ ir_variable *const r01E7 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r01E7, add(r01A5, body.constant(1u)), 0x01));
+
+ ir_expression *const r01E8 = less(r01E7, r01A5);
+ ir_expression *const r01E9 = expr(ir_unop_b2i, r01E8);
+ ir_expression *const r01EA = expr(ir_unop_i2u, r01E9);
+ body.emit(assign(r01A4, add(r01A4, r01EA), 0x01));
+
+ ir_expression *const r01EB = equal(r01A6, body.constant(0u));
+ ir_expression *const r01EC = expr(ir_unop_b2i, r01EB);
+ ir_expression *const r01ED = expr(ir_unop_i2u, r01EC);
+ ir_expression *const r01EE = add(r01A6, r01ED);
+ ir_expression *const r01EF = bit_and(r01EE, body.constant(1u));
+ ir_expression *const r01F0 = expr(ir_unop_bit_not, r01EF);
+ body.emit(assign(r01A5, bit_and(r01E7, r01F0), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f01E6->else_instructions;
+
+ ir_expression *const r01F1 = bit_or(r01A4, r01A5);
+ ir_expression *const r01F2 = equal(r01F1, body.constant(0u));
+ body.emit(assign(r01A3, expr(ir_triop_csel, r01F2, body.constant(int(0)), r01A3), 0x01));
+
+
+ body.instructions = f01E6_parent_instructions;
+ body.emit(f01E6);
+
+ /* END IF */
+
+ ir_variable *const r01F3 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r01F3);
+ ir_expression *const r01F4 = lshift(r015F, body.constant(int(31)));
+ ir_expression *const r01F5 = expr(ir_unop_i2u, r01A3);
+ ir_expression *const r01F6 = lshift(r01F5, body.constant(int(20)));
+ ir_expression *const r01F7 = add(r01F4, r01F6);
+ body.emit(assign(r01F3, add(r01F7, r01A4), 0x02));
+
+ body.emit(assign(r01F3, r01A5, 0x01));
+
+ body.emit(assign(r01A8, r01F3, 0x03));
+
+ body.emit(assign(r01A7, body.constant(false), 0x01));
+
+
+ body.instructions = f01E5_parent_instructions;
+ body.emit(f01E5);
+
+ /* END IF */
+
+ body.emit(ret(r01A8));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+propagateFloat64NaN(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::uvec2_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r01F8 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "a", ir_var_function_in);
+ sig_parameters.push_tail(r01F8);
+ ir_variable *const r01F9 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "b", ir_var_function_in);
+ sig_parameters.push_tail(r01F9);
+ ir_variable *const r01FA = body.make_temp(glsl_type::bool_type, "is_nan_retval");
+ ir_expression *const r01FB = lshift(swizzle_y(r01F8), body.constant(int(1)));
+ ir_expression *const r01FC = gequal(r01FB, body.constant(4292870144u));
+ ir_expression *const r01FD = nequal(swizzle_x(r01F8), body.constant(0u));
+ ir_expression *const r01FE = bit_and(swizzle_y(r01F8), body.constant(1048575u));
+ ir_expression *const r01FF = nequal(r01FE, body.constant(0u));
+ ir_expression *const r0200 = logic_or(r01FD, r01FF);
+ body.emit(assign(r01FA, logic_and(r01FC, r0200), 0x01));
+
+ ir_variable *const r0201 = body.make_temp(glsl_type::bool_type, "is_nan_retval");
+ ir_expression *const r0202 = lshift(swizzle_y(r01F9), body.constant(int(1)));
+ ir_expression *const r0203 = gequal(r0202, body.constant(4292870144u));
+ ir_expression *const r0204 = nequal(swizzle_x(r01F9), body.constant(0u));
+ ir_expression *const r0205 = bit_and(swizzle_y(r01F9), body.constant(1048575u));
+ ir_expression *const r0206 = nequal(r0205, body.constant(0u));
+ ir_expression *const r0207 = logic_or(r0204, r0206);
+ body.emit(assign(r0201, logic_and(r0203, r0207), 0x01));
+
+ body.emit(assign(r01F8, bit_or(swizzle_y(r01F8), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r01F9, bit_or(swizzle_y(r01F9), body.constant(524288u)), 0x02));
+
+ ir_variable *const r0208 = body.make_temp(glsl_type::uvec2_type, "mix_retval");
+ ir_swizzle *const r0209 = swizzle(r01FA, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_swizzle *const r020A = swizzle(r0201, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r020B = expr(ir_triop_csel, r020A, r01F9, r01F8);
+ body.emit(assign(r0208, expr(ir_triop_csel, r0209, r020B, r01F9), 0x03));
+
+ body.emit(ret(r0208));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+fadd64(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::uvec2_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r020C = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "a", ir_var_function_in);
+ sig_parameters.push_tail(r020C);
+ ir_variable *const r020D = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "b", ir_var_function_in);
+ sig_parameters.push_tail(r020D);
+ ir_variable *const r020E = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r020E, body.constant(true), 0x01));
+
+ ir_variable *const r020F = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r0210 = new(mem_ctx) ir_variable(glsl_type::int_type, "expDiff", ir_var_auto);
+ body.emit(r0210);
+ ir_variable *const r0211 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac1", ir_var_auto);
+ body.emit(r0211);
+ ir_variable *const r0212 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac0", ir_var_auto);
+ body.emit(r0212);
+ ir_variable *const r0213 = new(mem_ctx) ir_variable(glsl_type::int_type, "bExp", ir_var_auto);
+ body.emit(r0213);
+ ir_variable *const r0214 = new(mem_ctx) ir_variable(glsl_type::int_type, "aExp", ir_var_auto);
+ body.emit(r0214);
+ ir_variable *const r0215 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bFracHi", ir_var_auto);
+ body.emit(r0215);
+ ir_variable *const r0216 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bFracLo", ir_var_auto);
+ body.emit(r0216);
+ ir_variable *const r0217 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aFracHi", ir_var_auto);
+ body.emit(r0217);
+ ir_variable *const r0218 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aFracLo", ir_var_auto);
+ body.emit(r0218);
+ ir_variable *const r0219 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aSign", ir_var_auto);
+ body.emit(r0219);
+ ir_variable *const r021A = body.make_temp(glsl_type::uint_type, "extractFloat64Sign_retval");
+ body.emit(assign(r021A, rshift(swizzle_y(r020C), body.constant(int(31))), 0x01));
+
+ body.emit(assign(r0219, r021A, 0x01));
+
+ ir_variable *const r021B = body.make_temp(glsl_type::uint_type, "extractFloat64Sign_retval");
+ body.emit(assign(r021B, rshift(swizzle_y(r020D), body.constant(int(31))), 0x01));
+
+ body.emit(assign(r0218, swizzle_x(r020C), 0x01));
+
+ ir_variable *const r021C = body.make_temp(glsl_type::uint_type, "extractFloat64FracHi_retval");
+ body.emit(assign(r021C, bit_and(swizzle_y(r020C), body.constant(1048575u)), 0x01));
+
+ body.emit(assign(r0217, r021C, 0x01));
+
+ body.emit(assign(r0216, swizzle_x(r020D), 0x01));
+
+ ir_variable *const r021D = body.make_temp(glsl_type::uint_type, "extractFloat64FracHi_retval");
+ body.emit(assign(r021D, bit_and(swizzle_y(r020D), body.constant(1048575u)), 0x01));
+
+ body.emit(assign(r0215, r021D, 0x01));
+
+ ir_variable *const r021E = body.make_temp(glsl_type::int_type, "extractFloat64Exp_retval");
+ ir_expression *const r021F = rshift(swizzle_y(r020C), body.constant(int(20)));
+ ir_expression *const r0220 = bit_and(r021F, body.constant(2047u));
+ body.emit(assign(r021E, expr(ir_unop_u2i, r0220), 0x01));
+
+ body.emit(assign(r0214, r021E, 0x01));
+
+ ir_variable *const r0221 = body.make_temp(glsl_type::int_type, "extractFloat64Exp_retval");
+ ir_expression *const r0222 = rshift(swizzle_y(r020D), body.constant(int(20)));
+ ir_expression *const r0223 = bit_and(r0222, body.constant(2047u));
+ body.emit(assign(r0221, expr(ir_unop_u2i, r0223), 0x01));
+
+ body.emit(assign(r0213, r0221, 0x01));
+
+ body.emit(assign(r0212, body.constant(0u), 0x01));
+
+ body.emit(assign(r0211, body.constant(0u), 0x01));
+
+ ir_variable *const r0224 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ body.emit(assign(r0224, sub(r021E, r0221), 0x01));
+
+ body.emit(assign(r0210, r0224, 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0226 = equal(r021A, r021B);
+ ir_if *f0225 = new(mem_ctx) ir_if(operand(r0226).val);
+ exec_list *const f0225_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0225->then_instructions;
+
+ ir_variable *const r0227 = new(mem_ctx) ir_variable(glsl_type::int_type, "zExp", ir_var_auto);
+ body.emit(r0227);
+ ir_variable *const r0228 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac2", ir_var_auto);
+ body.emit(r0228);
+ body.emit(assign(r0228, body.constant(0u), 0x01));
+
+ ir_variable *const r0229 = body.make_temp(glsl_type::bool_type, "assignment_tmp");
+ body.emit(assign(r0229, equal(r0224, body.constant(int(0))), 0x01));
+
+ /* IF CONDITION */
+ ir_if *f022A = new(mem_ctx) ir_if(operand(r0229).val);
+ exec_list *const f022A_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f022A->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r022C = equal(r021E, body.constant(int(2047)));
+ ir_if *f022B = new(mem_ctx) ir_if(operand(r022C).val);
+ exec_list *const f022B_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f022B->then_instructions;
+
+ ir_variable *const r022D = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r022D, swizzle_x(r020C), 0x01));
+
+ ir_variable *const r022E = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r022E, swizzle_x(r020D), 0x01));
+
+ body.emit(assign(r022D, bit_or(swizzle_y(r020C), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r022E, bit_or(swizzle_y(r020D), body.constant(524288u)), 0x02));
+
+ ir_expression *const r022F = bit_or(r021C, swizzle_x(r020C));
+ ir_expression *const r0230 = bit_or(r021D, swizzle_x(r020D));
+ ir_expression *const r0231 = bit_or(r022F, r0230);
+ ir_expression *const r0232 = nequal(r0231, body.constant(0u));
+ ir_swizzle *const r0233 = swizzle(r0232, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0234 = lshift(swizzle_y(r020C), body.constant(int(1)));
+ ir_expression *const r0235 = gequal(r0234, body.constant(4292870144u));
+ ir_expression *const r0236 = nequal(swizzle_x(r020C), body.constant(0u));
+ ir_expression *const r0237 = bit_and(swizzle_y(r020C), body.constant(1048575u));
+ ir_expression *const r0238 = nequal(r0237, body.constant(0u));
+ ir_expression *const r0239 = logic_or(r0236, r0238);
+ ir_expression *const r023A = logic_and(r0235, r0239);
+ ir_swizzle *const r023B = swizzle(r023A, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r023C = lshift(swizzle_y(r020D), body.constant(int(1)));
+ ir_expression *const r023D = gequal(r023C, body.constant(4292870144u));
+ ir_expression *const r023E = nequal(swizzle_x(r020D), body.constant(0u));
+ ir_expression *const r023F = bit_and(swizzle_y(r020D), body.constant(1048575u));
+ ir_expression *const r0240 = nequal(r023F, body.constant(0u));
+ ir_expression *const r0241 = logic_or(r023E, r0240);
+ ir_expression *const r0242 = logic_and(r023D, r0241);
+ ir_swizzle *const r0243 = swizzle(r0242, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0244 = expr(ir_triop_csel, r0243, r022E, r022D);
+ ir_expression *const r0245 = expr(ir_triop_csel, r023B, r0244, r022E);
+ body.emit(assign(r020F, expr(ir_triop_csel, r0233, r0245, r020C), 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f022B->else_instructions;
+
+ ir_variable *const r0246 = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r0247 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r0247, add(swizzle_x(r020C), swizzle_x(r020D)), 0x01));
+
+ ir_expression *const r0248 = add(r021C, r021D);
+ ir_expression *const r0249 = less(r0247, swizzle_x(r020C));
+ ir_expression *const r024A = expr(ir_unop_b2i, r0249);
+ ir_expression *const r024B = expr(ir_unop_i2u, r024A);
+ body.emit(assign(r0246, add(r0248, r024B), 0x01));
+
+ body.emit(assign(r0212, r0246, 0x01));
+
+ body.emit(assign(r0211, r0247, 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r024D = equal(r021E, body.constant(int(0)));
+ ir_if *f024C = new(mem_ctx) ir_if(operand(r024D).val);
+ exec_list *const f024C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f024C->then_instructions;
+
+ ir_variable *const r024E = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r024E);
+ ir_expression *const r024F = lshift(r021A, body.constant(int(31)));
+ body.emit(assign(r024E, add(r024F, r0246), 0x02));
+
+ body.emit(assign(r024E, r0247, 0x01));
+
+ body.emit(assign(r020F, r024E, 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f024C->else_instructions;
+
+ body.emit(assign(r0212, bit_or(r0246, body.constant(2097152u)), 0x01));
+
+ body.emit(assign(r0227, r021E, 0x01));
+
+ ir_variable *const r0250 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ ir_expression *const r0251 = lshift(r0212, body.constant(int(31)));
+ ir_expression *const r0252 = rshift(r0247, body.constant(int(1)));
+ body.emit(assign(r0250, bit_or(r0251, r0252), 0x01));
+
+ body.emit(assign(r0212, rshift(r0212, body.constant(int(1))), 0x01));
+
+ body.emit(assign(r0211, r0250, 0x01));
+
+ ir_expression *const r0253 = lshift(r0247, body.constant(int(31)));
+ body.emit(assign(r0228, bit_or(r0253, body.constant(0u)), 0x01));
+
+
+ body.instructions = f024C_parent_instructions;
+ body.emit(f024C);
+
+ /* END IF */
+
+
+ body.instructions = f022B_parent_instructions;
+ body.emit(f022B);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f022A->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0255 = less(body.constant(int(0)), r0224);
+ ir_if *f0254 = new(mem_ctx) ir_if(operand(r0255).val);
+ exec_list *const f0254_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0254->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0257 = equal(r021E, body.constant(int(2047)));
+ ir_if *f0256 = new(mem_ctx) ir_if(operand(r0257).val);
+ exec_list *const f0256_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0256->then_instructions;
+
+ ir_variable *const r0258 = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r0258, swizzle_x(r020C), 0x01));
+
+ ir_variable *const r0259 = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r0259, swizzle_x(r020D), 0x01));
+
+ body.emit(assign(r0258, bit_or(swizzle_y(r020C), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r0259, bit_or(swizzle_y(r020D), body.constant(524288u)), 0x02));
+
+ ir_expression *const r025A = bit_or(r021C, swizzle_x(r020C));
+ ir_expression *const r025B = nequal(r025A, body.constant(0u));
+ ir_swizzle *const r025C = swizzle(r025B, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r025D = lshift(swizzle_y(r020C), body.constant(int(1)));
+ ir_expression *const r025E = gequal(r025D, body.constant(4292870144u));
+ ir_expression *const r025F = nequal(swizzle_x(r020C), body.constant(0u));
+ ir_expression *const r0260 = bit_and(swizzle_y(r020C), body.constant(1048575u));
+ ir_expression *const r0261 = nequal(r0260, body.constant(0u));
+ ir_expression *const r0262 = logic_or(r025F, r0261);
+ ir_expression *const r0263 = logic_and(r025E, r0262);
+ ir_swizzle *const r0264 = swizzle(r0263, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0265 = lshift(swizzle_y(r020D), body.constant(int(1)));
+ ir_expression *const r0266 = gequal(r0265, body.constant(4292870144u));
+ ir_expression *const r0267 = nequal(swizzle_x(r020D), body.constant(0u));
+ ir_expression *const r0268 = bit_and(swizzle_y(r020D), body.constant(1048575u));
+ ir_expression *const r0269 = nequal(r0268, body.constant(0u));
+ ir_expression *const r026A = logic_or(r0267, r0269);
+ ir_expression *const r026B = logic_and(r0266, r026A);
+ ir_swizzle *const r026C = swizzle(r026B, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r026D = expr(ir_triop_csel, r026C, r0259, r0258);
+ ir_expression *const r026E = expr(ir_triop_csel, r0264, r026D, r0259);
+ body.emit(assign(r020F, expr(ir_triop_csel, r025C, r026E, r020C), 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0256->else_instructions;
+
+ ir_variable *const r026F = body.make_temp(glsl_type::int_type, "mix_retval");
+ ir_expression *const r0270 = equal(r0221, body.constant(int(0)));
+ ir_expression *const r0271 = add(r0224, body.constant(int(-1)));
+ body.emit(assign(r026F, expr(ir_triop_csel, r0270, r0271, r0224), 0x01));
+
+ body.emit(assign(r0210, r026F, 0x01));
+
+ ir_variable *const r0272 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0273 = equal(r0221, body.constant(int(0)));
+ ir_expression *const r0274 = bit_or(r021D, body.constant(1048576u));
+ body.emit(assign(r0272, expr(ir_triop_csel, r0273, r021D, r0274), 0x01));
+
+ ir_variable *const r0275 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r0275);
+ ir_variable *const r0276 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r0277 = neg(r026F);
+ body.emit(assign(r0276, bit_and(r0277, body.constant(int(31))), 0x01));
+
+ ir_variable *const r0278 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0279 = less(r026F, body.constant(int(32)));
+ ir_expression *const r027A = bit_or(body.constant(0u), swizzle_x(r020D));
+ body.emit(assign(r0278, expr(ir_triop_csel, r0279, body.constant(0u), r027A), 0x01));
+
+ ir_expression *const r027B = less(r026F, body.constant(int(32)));
+ ir_expression *const r027C = lshift(swizzle_x(r020D), r0276);
+ ir_expression *const r027D = less(r026F, body.constant(int(64)));
+ ir_expression *const r027E = lshift(r0272, r0276);
+ ir_expression *const r027F = equal(r026F, body.constant(int(64)));
+ ir_expression *const r0280 = nequal(r0272, body.constant(0u));
+ ir_expression *const r0281 = expr(ir_unop_b2i, r0280);
+ ir_expression *const r0282 = expr(ir_unop_i2u, r0281);
+ ir_expression *const r0283 = expr(ir_triop_csel, r027F, r0272, r0282);
+ ir_expression *const r0284 = expr(ir_triop_csel, r027D, r027E, r0283);
+ ir_expression *const r0285 = expr(ir_triop_csel, r027B, r027C, r0284);
+ ir_expression *const r0286 = nequal(r0278, body.constant(0u));
+ ir_expression *const r0287 = expr(ir_unop_b2i, r0286);
+ ir_expression *const r0288 = expr(ir_unop_i2u, r0287);
+ body.emit(assign(r0275, bit_or(r0285, r0288), 0x01));
+
+ ir_variable *const r0289 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r028A = equal(r026F, body.constant(int(0)));
+ ir_expression *const r028B = equal(r026F, body.constant(int(32)));
+ ir_expression *const r028C = expr(ir_triop_csel, r028B, swizzle_x(r020D), r0275);
+ body.emit(assign(r0289, expr(ir_triop_csel, r028A, r0278, r028C), 0x01));
+
+ body.emit(assign(r0275, r0289, 0x01));
+
+ ir_expression *const r028D = equal(r026F, body.constant(int(0)));
+ ir_expression *const r028E = equal(r026F, body.constant(int(32)));
+ ir_expression *const r028F = less(r026F, body.constant(int(32)));
+ ir_expression *const r0290 = rshift(r0272, r026F);
+ ir_expression *const r0291 = expr(ir_triop_csel, r028F, r0290, body.constant(0u));
+ ir_expression *const r0292 = expr(ir_triop_csel, r028E, body.constant(0u), r0291);
+ body.emit(assign(r0215, expr(ir_triop_csel, r028D, r0272, r0292), 0x01));
+
+ ir_expression *const r0293 = equal(r026F, body.constant(int(0)));
+ ir_expression *const r0294 = equal(r026F, body.constant(int(32)));
+ ir_expression *const r0295 = less(r026F, body.constant(int(32)));
+ ir_expression *const r0296 = lshift(r0272, r0276);
+ ir_expression *const r0297 = rshift(swizzle_x(r020D), r026F);
+ ir_expression *const r0298 = bit_or(r0296, r0297);
+ ir_expression *const r0299 = less(r026F, body.constant(int(64)));
+ ir_expression *const r029A = bit_and(r026F, body.constant(int(31)));
+ ir_expression *const r029B = rshift(r0272, r029A);
+ ir_expression *const r029C = expr(ir_triop_csel, r0299, r029B, body.constant(0u));
+ ir_expression *const r029D = expr(ir_triop_csel, r0295, r0298, r029C);
+ ir_expression *const r029E = expr(ir_triop_csel, r0294, r0272, r029D);
+ body.emit(assign(r0216, expr(ir_triop_csel, r0293, swizzle_x(r020D), r029E), 0x01));
+
+ body.emit(assign(r0228, r0289, 0x01));
+
+ body.emit(assign(r0227, r021E, 0x01));
+
+
+ body.instructions = f0256_parent_instructions;
+ body.emit(f0256);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0254->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r02A0 = less(r0210, body.constant(int(0)));
+ ir_if *f029F = new(mem_ctx) ir_if(operand(r02A0).val);
+ exec_list *const f029F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f029F->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r02A2 = equal(r0221, body.constant(int(2047)));
+ ir_if *f02A1 = new(mem_ctx) ir_if(operand(r02A2).val);
+ exec_list *const f02A1_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f02A1->then_instructions;
+
+ ir_variable *const r02A3 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r02A3);
+ ir_expression *const r02A4 = lshift(r021A, body.constant(int(31)));
+ body.emit(assign(r02A3, add(r02A4, body.constant(2146435072u)), 0x02));
+
+ body.emit(assign(r02A3, body.constant(0u), 0x01));
+
+ ir_variable *const r02A5 = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r02A5, swizzle_x(r020C), 0x01));
+
+ ir_variable *const r02A6 = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r02A6, swizzle_x(r020D), 0x01));
+
+ body.emit(assign(r02A5, bit_or(swizzle_y(r020C), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r02A6, bit_or(swizzle_y(r020D), body.constant(524288u)), 0x02));
+
+ ir_expression *const r02A7 = bit_or(r0215, r0216);
+ ir_expression *const r02A8 = nequal(r02A7, body.constant(0u));
+ ir_swizzle *const r02A9 = swizzle(r02A8, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r02AA = lshift(swizzle_y(r020C), body.constant(int(1)));
+ ir_expression *const r02AB = gequal(r02AA, body.constant(4292870144u));
+ ir_expression *const r02AC = nequal(swizzle_x(r020C), body.constant(0u));
+ ir_expression *const r02AD = bit_and(swizzle_y(r020C), body.constant(1048575u));
+ ir_expression *const r02AE = nequal(r02AD, body.constant(0u));
+ ir_expression *const r02AF = logic_or(r02AC, r02AE);
+ ir_expression *const r02B0 = logic_and(r02AB, r02AF);
+ ir_swizzle *const r02B1 = swizzle(r02B0, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r02B2 = lshift(swizzle_y(r020D), body.constant(int(1)));
+ ir_expression *const r02B3 = gequal(r02B2, body.constant(4292870144u));
+ ir_expression *const r02B4 = nequal(swizzle_x(r020D), body.constant(0u));
+ ir_expression *const r02B5 = bit_and(swizzle_y(r020D), body.constant(1048575u));
+ ir_expression *const r02B6 = nequal(r02B5, body.constant(0u));
+ ir_expression *const r02B7 = logic_or(r02B4, r02B6);
+ ir_expression *const r02B8 = logic_and(r02B3, r02B7);
+ ir_swizzle *const r02B9 = swizzle(r02B8, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r02BA = expr(ir_triop_csel, r02B9, r02A6, r02A5);
+ ir_expression *const r02BB = expr(ir_triop_csel, r02B1, r02BA, r02A6);
+ body.emit(assign(r020F, expr(ir_triop_csel, r02A9, r02BB, r02A3), 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f02A1->else_instructions;
+
+ ir_variable *const r02BC = body.make_temp(glsl_type::int_type, "mix_retval");
+ ir_expression *const r02BD = equal(r021E, body.constant(int(0)));
+ ir_expression *const r02BE = add(r0210, body.constant(int(1)));
+ body.emit(assign(r02BC, expr(ir_triop_csel, r02BD, r02BE, r0210), 0x01));
+
+ body.emit(assign(r0210, r02BC, 0x01));
+
+ ir_variable *const r02BF = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r02C0 = equal(r021E, body.constant(int(0)));
+ ir_expression *const r02C1 = bit_or(r021C, body.constant(1048576u));
+ body.emit(assign(r02BF, expr(ir_triop_csel, r02C0, r021C, r02C1), 0x01));
+
+ ir_variable *const r02C2 = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r02C2, neg(r02BC), 0x01));
+
+ ir_variable *const r02C3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r02C3);
+ ir_variable *const r02C4 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r02C5 = neg(r02C2);
+ body.emit(assign(r02C4, bit_and(r02C5, body.constant(int(31))), 0x01));
+
+ ir_variable *const r02C6 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r02C7 = less(r02C2, body.constant(int(32)));
+ ir_expression *const r02C8 = bit_or(body.constant(0u), swizzle_x(r020C));
+ body.emit(assign(r02C6, expr(ir_triop_csel, r02C7, body.constant(0u), r02C8), 0x01));
+
+ ir_expression *const r02C9 = less(r02C2, body.constant(int(32)));
+ ir_expression *const r02CA = lshift(swizzle_x(r020C), r02C4);
+ ir_expression *const r02CB = less(r02C2, body.constant(int(64)));
+ ir_expression *const r02CC = lshift(r02BF, r02C4);
+ ir_expression *const r02CD = equal(r02C2, body.constant(int(64)));
+ ir_expression *const r02CE = nequal(r02BF, body.constant(0u));
+ ir_expression *const r02CF = expr(ir_unop_b2i, r02CE);
+ ir_expression *const r02D0 = expr(ir_unop_i2u, r02CF);
+ ir_expression *const r02D1 = expr(ir_triop_csel, r02CD, r02BF, r02D0);
+ ir_expression *const r02D2 = expr(ir_triop_csel, r02CB, r02CC, r02D1);
+ ir_expression *const r02D3 = expr(ir_triop_csel, r02C9, r02CA, r02D2);
+ ir_expression *const r02D4 = nequal(r02C6, body.constant(0u));
+ ir_expression *const r02D5 = expr(ir_unop_b2i, r02D4);
+ ir_expression *const r02D6 = expr(ir_unop_i2u, r02D5);
+ body.emit(assign(r02C3, bit_or(r02D3, r02D6), 0x01));
+
+ ir_variable *const r02D7 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r02D8 = equal(r02C2, body.constant(int(0)));
+ ir_expression *const r02D9 = equal(r02C2, body.constant(int(32)));
+ ir_expression *const r02DA = expr(ir_triop_csel, r02D9, swizzle_x(r020C), r02C3);
+ body.emit(assign(r02D7, expr(ir_triop_csel, r02D8, r02C6, r02DA), 0x01));
+
+ body.emit(assign(r02C3, r02D7, 0x01));
+
+ ir_expression *const r02DB = equal(r02C2, body.constant(int(0)));
+ ir_expression *const r02DC = equal(r02C2, body.constant(int(32)));
+ ir_expression *const r02DD = less(r02C2, body.constant(int(32)));
+ ir_expression *const r02DE = rshift(r02BF, r02C2);
+ ir_expression *const r02DF = expr(ir_triop_csel, r02DD, r02DE, body.constant(0u));
+ ir_expression *const r02E0 = expr(ir_triop_csel, r02DC, body.constant(0u), r02DF);
+ body.emit(assign(r0217, expr(ir_triop_csel, r02DB, r02BF, r02E0), 0x01));
+
+ ir_expression *const r02E1 = equal(r02C2, body.constant(int(0)));
+ ir_expression *const r02E2 = equal(r02C2, body.constant(int(32)));
+ ir_expression *const r02E3 = less(r02C2, body.constant(int(32)));
+ ir_expression *const r02E4 = lshift(r02BF, r02C4);
+ ir_expression *const r02E5 = rshift(swizzle_x(r020C), r02C2);
+ ir_expression *const r02E6 = bit_or(r02E4, r02E5);
+ ir_expression *const r02E7 = less(r02C2, body.constant(int(64)));
+ ir_expression *const r02E8 = bit_and(r02C2, body.constant(int(31)));
+ ir_expression *const r02E9 = rshift(r02BF, r02E8);
+ ir_expression *const r02EA = expr(ir_triop_csel, r02E7, r02E9, body.constant(0u));
+ ir_expression *const r02EB = expr(ir_triop_csel, r02E3, r02E6, r02EA);
+ ir_expression *const r02EC = expr(ir_triop_csel, r02E2, r02BF, r02EB);
+ body.emit(assign(r0218, expr(ir_triop_csel, r02E1, swizzle_x(r020C), r02EC), 0x01));
+
+ body.emit(assign(r0228, r02D7, 0x01));
+
+ body.emit(assign(r0227, r0221, 0x01));
+
+
+ body.instructions = f02A1_parent_instructions;
+ body.emit(f02A1);
+
+ /* END IF */
+
+
+ body.instructions = f029F_parent_instructions;
+ body.emit(f029F);
+
+ /* END IF */
+
+
+ body.instructions = f0254_parent_instructions;
+ body.emit(f0254);
+
+ /* END IF */
+
+
+ body.instructions = f022A_parent_instructions;
+ body.emit(f022A);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f02ED = new(mem_ctx) ir_if(operand(r020E).val);
+ exec_list *const f02ED_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f02ED->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r02EF = expr(ir_unop_logic_not, r0229);
+ ir_if *f02EE = new(mem_ctx) ir_if(operand(r02EF).val);
+ exec_list *const f02EE_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f02EE->then_instructions;
+
+ body.emit(assign(r0217, bit_or(r0217, body.constant(1048576u)), 0x01));
+
+ ir_variable *const r02F0 = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r02F1 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r02F1, add(r0218, r0216), 0x01));
+
+ ir_expression *const r02F2 = add(r0217, r0215);
+ ir_expression *const r02F3 = less(r02F1, r0218);
+ ir_expression *const r02F4 = expr(ir_unop_b2i, r02F3);
+ ir_expression *const r02F5 = expr(ir_unop_i2u, r02F4);
+ body.emit(assign(r02F0, add(r02F2, r02F5), 0x01));
+
+ body.emit(assign(r0212, r02F0, 0x01));
+
+ body.emit(assign(r0211, r02F1, 0x01));
+
+ body.emit(assign(r0227, add(r0227, body.constant(int(-1))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r02F7 = gequal(r02F0, body.constant(2097152u));
+ ir_if *f02F6 = new(mem_ctx) ir_if(operand(r02F7).val);
+ exec_list *const f02F6_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f02F6->then_instructions;
+
+ body.emit(assign(r0212, rshift(r02F0, body.constant(int(1))), 0x01));
+
+ ir_expression *const r02F8 = lshift(r02F0, body.constant(int(31)));
+ ir_expression *const r02F9 = rshift(r02F1, body.constant(int(1)));
+ body.emit(assign(r0211, bit_or(r02F8, r02F9), 0x01));
+
+ ir_expression *const r02FA = lshift(r02F1, body.constant(int(31)));
+ ir_expression *const r02FB = nequal(r0228, body.constant(0u));
+ ir_expression *const r02FC = expr(ir_unop_b2i, r02FB);
+ ir_expression *const r02FD = expr(ir_unop_i2u, r02FC);
+ body.emit(assign(r0228, bit_or(r02FA, r02FD), 0x01));
+
+ body.emit(assign(r0227, add(r0227, body.constant(int(1))), 0x01));
+
+
+ body.instructions = f02F6_parent_instructions;
+ body.emit(f02F6);
+
+ /* END IF */
+
+
+ body.instructions = f02EE_parent_instructions;
+ body.emit(f02EE);
+
+ /* END IF */
+
+ ir_variable *const r02FE = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r02FE, r0227, 0x01));
+
+ ir_variable *const r02FF = body.make_temp(glsl_type::uint_type, "zFrac0");
+ body.emit(assign(r02FF, r0212, 0x01));
+
+ ir_variable *const r0300 = body.make_temp(glsl_type::uint_type, "zFrac1");
+ body.emit(assign(r0300, r0211, 0x01));
+
+ ir_variable *const r0301 = body.make_temp(glsl_type::uint_type, "zFrac2");
+ body.emit(assign(r0301, r0228, 0x01));
+
+ ir_variable *const r0302 = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r0302, body.constant(true), 0x01));
+
+ ir_variable *const r0303 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r0304 = new(mem_ctx) ir_variable(glsl_type::bool_type, "increment", ir_var_auto);
+ body.emit(r0304);
+ ir_expression *const r0305 = expr(ir_unop_u2i, r0228);
+ body.emit(assign(r0304, less(r0305, body.constant(int(0))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0307 = gequal(r0227, body.constant(int(2045)));
+ ir_if *f0306 = new(mem_ctx) ir_if(operand(r0307).val);
+ exec_list *const f0306_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0306->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0309 = less(body.constant(int(2045)), r0227);
+ ir_expression *const r030A = equal(r0227, body.constant(int(2045)));
+ ir_expression *const r030B = equal(body.constant(2097151u), r0212);
+ ir_expression *const r030C = equal(body.constant(4294967295u), r0211);
+ ir_expression *const r030D = logic_and(r030B, r030C);
+ ir_expression *const r030E = logic_and(r030A, r030D);
+ ir_expression *const r030F = logic_and(r030E, r0304);
+ ir_expression *const r0310 = logic_or(r0309, r030F);
+ ir_if *f0308 = new(mem_ctx) ir_if(operand(r0310).val);
+ exec_list *const f0308_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0308->then_instructions;
+
+ ir_variable *const r0311 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0311);
+ ir_expression *const r0312 = lshift(r021A, body.constant(int(31)));
+ body.emit(assign(r0311, add(r0312, body.constant(2146435072u)), 0x02));
+
+ body.emit(assign(r0311, body.constant(0u), 0x01));
+
+ body.emit(assign(r0303, r0311, 0x03));
+
+ body.emit(assign(r0302, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0308->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0314 = less(r0227, body.constant(int(0)));
+ ir_if *f0313 = new(mem_ctx) ir_if(operand(r0314).val);
+ exec_list *const f0313_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0313->then_instructions;
+
+ ir_variable *const r0315 = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r0315, neg(r0227), 0x01));
+
+ ir_variable *const r0316 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r0316);
+ ir_variable *const r0317 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r0318 = neg(r0315);
+ body.emit(assign(r0317, bit_and(r0318, body.constant(int(31))), 0x01));
+
+ ir_variable *const r0319 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r031A = less(r0315, body.constant(int(32)));
+ ir_expression *const r031B = bit_or(r0228, r0211);
+ body.emit(assign(r0319, expr(ir_triop_csel, r031A, r0228, r031B), 0x01));
+
+ ir_expression *const r031C = less(r0315, body.constant(int(32)));
+ ir_expression *const r031D = lshift(r0211, r0317);
+ ir_expression *const r031E = less(r0315, body.constant(int(64)));
+ ir_expression *const r031F = lshift(r0212, r0317);
+ ir_expression *const r0320 = equal(r0315, body.constant(int(64)));
+ ir_expression *const r0321 = nequal(r0212, body.constant(0u));
+ ir_expression *const r0322 = expr(ir_unop_b2i, r0321);
+ ir_expression *const r0323 = expr(ir_unop_i2u, r0322);
+ ir_expression *const r0324 = expr(ir_triop_csel, r0320, r0212, r0323);
+ ir_expression *const r0325 = expr(ir_triop_csel, r031E, r031F, r0324);
+ ir_expression *const r0326 = expr(ir_triop_csel, r031C, r031D, r0325);
+ ir_expression *const r0327 = nequal(r0319, body.constant(0u));
+ ir_expression *const r0328 = expr(ir_unop_b2i, r0327);
+ ir_expression *const r0329 = expr(ir_unop_i2u, r0328);
+ body.emit(assign(r0316, bit_or(r0326, r0329), 0x01));
+
+ ir_variable *const r032A = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r032B = equal(r0315, body.constant(int(0)));
+ ir_expression *const r032C = equal(r0315, body.constant(int(32)));
+ ir_expression *const r032D = expr(ir_triop_csel, r032C, r0211, r0316);
+ body.emit(assign(r032A, expr(ir_triop_csel, r032B, r0319, r032D), 0x01));
+
+ body.emit(assign(r0316, r032A, 0x01));
+
+ ir_expression *const r032E = equal(r0315, body.constant(int(0)));
+ ir_expression *const r032F = equal(r0315, body.constant(int(32)));
+ ir_expression *const r0330 = less(r0315, body.constant(int(32)));
+ ir_expression *const r0331 = rshift(r0212, r0315);
+ ir_expression *const r0332 = expr(ir_triop_csel, r0330, r0331, body.constant(0u));
+ ir_expression *const r0333 = expr(ir_triop_csel, r032F, body.constant(0u), r0332);
+ body.emit(assign(r02FF, expr(ir_triop_csel, r032E, r0212, r0333), 0x01));
+
+ ir_expression *const r0334 = equal(r0315, body.constant(int(0)));
+ ir_expression *const r0335 = equal(r0315, body.constant(int(32)));
+ ir_expression *const r0336 = less(r0315, body.constant(int(32)));
+ ir_expression *const r0337 = lshift(r0212, r0317);
+ ir_expression *const r0338 = rshift(r0211, r0315);
+ ir_expression *const r0339 = bit_or(r0337, r0338);
+ ir_expression *const r033A = less(r0315, body.constant(int(64)));
+ ir_expression *const r033B = bit_and(r0315, body.constant(int(31)));
+ ir_expression *const r033C = rshift(r0212, r033B);
+ ir_expression *const r033D = expr(ir_triop_csel, r033A, r033C, body.constant(0u));
+ ir_expression *const r033E = expr(ir_triop_csel, r0336, r0339, r033D);
+ ir_expression *const r033F = expr(ir_triop_csel, r0335, r0212, r033E);
+ body.emit(assign(r0300, expr(ir_triop_csel, r0334, r0211, r033F), 0x01));
+
+ body.emit(assign(r0301, r032A, 0x01));
+
+ body.emit(assign(r02FE, body.constant(int(0)), 0x01));
+
+ body.emit(assign(r0304, less(r032A, body.constant(0u)), 0x01));
+
+
+ body.instructions = f0313_parent_instructions;
+ body.emit(f0313);
+
+ /* END IF */
+
+
+ body.instructions = f0308_parent_instructions;
+ body.emit(f0308);
+
+ /* END IF */
+
+
+ body.instructions = f0306_parent_instructions;
+ body.emit(f0306);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f0340 = new(mem_ctx) ir_if(operand(r0302).val);
+ exec_list *const f0340_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0340->then_instructions;
+
+ /* IF CONDITION */
+ ir_if *f0341 = new(mem_ctx) ir_if(operand(r0304).val);
+ exec_list *const f0341_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0341->then_instructions;
+
+ ir_variable *const r0342 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r0342, add(r0300, body.constant(1u)), 0x01));
+
+ ir_expression *const r0343 = less(r0342, r0300);
+ ir_expression *const r0344 = expr(ir_unop_b2i, r0343);
+ ir_expression *const r0345 = expr(ir_unop_i2u, r0344);
+ body.emit(assign(r02FF, add(r02FF, r0345), 0x01));
+
+ ir_expression *const r0346 = equal(r0301, body.constant(0u));
+ ir_expression *const r0347 = expr(ir_unop_b2i, r0346);
+ ir_expression *const r0348 = expr(ir_unop_i2u, r0347);
+ ir_expression *const r0349 = add(r0301, r0348);
+ ir_expression *const r034A = bit_and(r0349, body.constant(1u));
+ ir_expression *const r034B = expr(ir_unop_bit_not, r034A);
+ body.emit(assign(r0300, bit_and(r0342, r034B), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0341->else_instructions;
+
+ ir_expression *const r034C = bit_or(r02FF, r0300);
+ ir_expression *const r034D = equal(r034C, body.constant(0u));
+ body.emit(assign(r02FE, expr(ir_triop_csel, r034D, body.constant(int(0)), r02FE), 0x01));
+
+
+ body.instructions = f0341_parent_instructions;
+ body.emit(f0341);
+
+ /* END IF */
+
+ ir_variable *const r034E = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r034E);
+ ir_expression *const r034F = lshift(r021A, body.constant(int(31)));
+ ir_expression *const r0350 = expr(ir_unop_i2u, r02FE);
+ ir_expression *const r0351 = lshift(r0350, body.constant(int(20)));
+ ir_expression *const r0352 = add(r034F, r0351);
+ body.emit(assign(r034E, add(r0352, r02FF), 0x02));
+
+ body.emit(assign(r034E, r0300, 0x01));
+
+ body.emit(assign(r0303, r034E, 0x03));
+
+ body.emit(assign(r0302, body.constant(false), 0x01));
+
+
+ body.instructions = f0340_parent_instructions;
+ body.emit(f0340);
+
+ /* END IF */
+
+ body.emit(assign(r020F, r0303, 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ body.instructions = f02ED_parent_instructions;
+ body.emit(f02ED);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0225->else_instructions;
+
+ ir_variable *const r0353 = new(mem_ctx) ir_variable(glsl_type::bool_type, "blta", ir_var_auto);
+ body.emit(r0353);
+ ir_variable *const r0354 = new(mem_ctx) ir_variable(glsl_type::bool_type, "zexp_normal", ir_var_auto);
+ body.emit(r0354);
+ ir_variable *const r0355 = new(mem_ctx) ir_variable(glsl_type::int_type, "zExp", ir_var_auto);
+ body.emit(r0355);
+ ir_variable *const r0356 = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r0357 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r0357, lshift(r0218, body.constant(int(10))), 0x01));
+
+ ir_expression *const r0358 = lshift(r0217, body.constant(int(10)));
+ ir_expression *const r0359 = rshift(r0218, body.constant(int(22)));
+ body.emit(assign(r0356, bit_or(r0358, r0359), 0x01));
+
+ body.emit(assign(r0217, r0356, 0x01));
+
+ body.emit(assign(r0218, r0357, 0x01));
+
+ ir_variable *const r035A = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r035B = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r035B, lshift(r0216, body.constant(int(10))), 0x01));
+
+ ir_expression *const r035C = lshift(r0215, body.constant(int(10)));
+ ir_expression *const r035D = rshift(r0216, body.constant(int(22)));
+ body.emit(assign(r035A, bit_or(r035C, r035D), 0x01));
+
+ body.emit(assign(r0215, r035A, 0x01));
+
+ body.emit(assign(r0216, r035B, 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r035F = less(body.constant(int(0)), r0210);
+ ir_if *f035E = new(mem_ctx) ir_if(operand(r035F).val);
+ exec_list *const f035E_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f035E->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0361 = equal(r021E, body.constant(int(2047)));
+ ir_if *f0360 = new(mem_ctx) ir_if(operand(r0361).val);
+ exec_list *const f0360_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0360->then_instructions;
+
+ ir_variable *const r0362 = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r0362, swizzle_x(r020C), 0x01));
+
+ ir_variable *const r0363 = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r0363, swizzle_x(r020D), 0x01));
+
+ body.emit(assign(r0362, bit_or(swizzle_y(r020C), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r0363, bit_or(swizzle_y(r020D), body.constant(524288u)), 0x02));
+
+ ir_expression *const r0364 = bit_or(r0356, r0357);
+ ir_expression *const r0365 = nequal(r0364, body.constant(0u));
+ ir_swizzle *const r0366 = swizzle(r0365, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0367 = lshift(swizzle_y(r020C), body.constant(int(1)));
+ ir_expression *const r0368 = gequal(r0367, body.constant(4292870144u));
+ ir_expression *const r0369 = nequal(swizzle_x(r020C), body.constant(0u));
+ ir_expression *const r036A = bit_and(swizzle_y(r020C), body.constant(1048575u));
+ ir_expression *const r036B = nequal(r036A, body.constant(0u));
+ ir_expression *const r036C = logic_or(r0369, r036B);
+ ir_expression *const r036D = logic_and(r0368, r036C);
+ ir_swizzle *const r036E = swizzle(r036D, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r036F = lshift(swizzle_y(r020D), body.constant(int(1)));
+ ir_expression *const r0370 = gequal(r036F, body.constant(4292870144u));
+ ir_expression *const r0371 = nequal(swizzle_x(r020D), body.constant(0u));
+ ir_expression *const r0372 = bit_and(swizzle_y(r020D), body.constant(1048575u));
+ ir_expression *const r0373 = nequal(r0372, body.constant(0u));
+ ir_expression *const r0374 = logic_or(r0371, r0373);
+ ir_expression *const r0375 = logic_and(r0370, r0374);
+ ir_swizzle *const r0376 = swizzle(r0375, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0377 = expr(ir_triop_csel, r0376, r0363, r0362);
+ ir_expression *const r0378 = expr(ir_triop_csel, r036E, r0377, r0363);
+ body.emit(assign(r020F, expr(ir_triop_csel, r0366, r0378, r020C), 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0360->else_instructions;
+
+ ir_variable *const r0379 = body.make_temp(glsl_type::int_type, "mix_retval");
+ ir_expression *const r037A = equal(r0221, body.constant(int(0)));
+ ir_expression *const r037B = add(r0210, body.constant(int(-1)));
+ body.emit(assign(r0379, expr(ir_triop_csel, r037A, r037B, r0210), 0x01));
+
+ body.emit(assign(r0210, r0379, 0x01));
+
+ ir_variable *const r037C = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r037D = equal(r0221, body.constant(int(0)));
+ ir_expression *const r037E = bit_or(r035A, body.constant(1073741824u));
+ body.emit(assign(r037C, expr(ir_triop_csel, r037D, r035A, r037E), 0x01));
+
+ ir_variable *const r037F = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r0380 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0380);
+ ir_variable *const r0381 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r0382 = neg(r0379);
+ body.emit(assign(r0381, bit_and(r0382, body.constant(int(31))), 0x01));
+
+ ir_expression *const r0383 = bit_or(r037C, r035B);
+ ir_expression *const r0384 = nequal(r0383, body.constant(0u));
+ ir_expression *const r0385 = expr(ir_unop_b2i, r0384);
+ body.emit(assign(r0380, expr(ir_unop_i2u, r0385), 0x01));
+
+ ir_variable *const r0386 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0387 = equal(r0379, body.constant(int(0)));
+ ir_expression *const r0388 = less(r0379, body.constant(int(32)));
+ ir_expression *const r0389 = lshift(r037C, r0381);
+ ir_expression *const r038A = rshift(r035B, r0379);
+ ir_expression *const r038B = bit_or(r0389, r038A);
+ ir_expression *const r038C = lshift(r035B, r0381);
+ ir_expression *const r038D = nequal(r038C, body.constant(0u));
+ ir_expression *const r038E = expr(ir_unop_b2i, r038D);
+ ir_expression *const r038F = expr(ir_unop_i2u, r038E);
+ ir_expression *const r0390 = bit_or(r038B, r038F);
+ ir_expression *const r0391 = equal(r0379, body.constant(int(32)));
+ ir_expression *const r0392 = nequal(r035B, body.constant(0u));
+ ir_expression *const r0393 = expr(ir_unop_b2i, r0392);
+ ir_expression *const r0394 = expr(ir_unop_i2u, r0393);
+ ir_expression *const r0395 = bit_or(r037C, r0394);
+ ir_expression *const r0396 = less(r0379, body.constant(int(64)));
+ ir_expression *const r0397 = bit_and(r0379, body.constant(int(31)));
+ ir_expression *const r0398 = rshift(r037C, r0397);
+ ir_expression *const r0399 = lshift(r037C, r0381);
+ ir_expression *const r039A = bit_or(r0399, r035B);
+ ir_expression *const r039B = nequal(r039A, body.constant(0u));
+ ir_expression *const r039C = expr(ir_unop_b2i, r039B);
+ ir_expression *const r039D = expr(ir_unop_i2u, r039C);
+ ir_expression *const r039E = bit_or(r0398, r039D);
+ ir_expression *const r039F = expr(ir_triop_csel, r0396, r039E, r0380);
+ ir_expression *const r03A0 = expr(ir_triop_csel, r0391, r0395, r039F);
+ ir_expression *const r03A1 = expr(ir_triop_csel, r0388, r0390, r03A0);
+ body.emit(assign(r0386, expr(ir_triop_csel, r0387, r035B, r03A1), 0x01));
+
+ body.emit(assign(r0380, r0386, 0x01));
+
+ ir_expression *const r03A2 = less(r0379, body.constant(int(32)));
+ ir_expression *const r03A3 = rshift(r037C, r0379);
+ ir_expression *const r03A4 = equal(r0379, body.constant(int(0)));
+ ir_expression *const r03A5 = expr(ir_triop_csel, r03A4, r037C, body.constant(0u));
+ body.emit(assign(r037F, expr(ir_triop_csel, r03A2, r03A3, r03A5), 0x01));
+
+ body.emit(assign(r0215, r037F, 0x01));
+
+ body.emit(assign(r0216, r0386, 0x01));
+
+ body.emit(assign(r0217, bit_or(r0356, body.constant(1073741824u)), 0x01));
+
+ ir_variable *const r03A6 = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r03A7 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r03A7, sub(r0357, r0386), 0x01));
+
+ ir_expression *const r03A8 = sub(r0217, r037F);
+ ir_expression *const r03A9 = less(r0357, r0386);
+ ir_expression *const r03AA = expr(ir_unop_b2i, r03A9);
+ ir_expression *const r03AB = expr(ir_unop_i2u, r03AA);
+ body.emit(assign(r03A6, sub(r03A8, r03AB), 0x01));
+
+ body.emit(assign(r0212, r03A6, 0x01));
+
+ body.emit(assign(r0211, r03A7, 0x01));
+
+ body.emit(assign(r0355, add(r021E, body.constant(int(-1))), 0x01));
+
+ ir_variable *const r03AC = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r03AC, add(r0355, body.constant(int(-10))), 0x01));
+
+ ir_variable *const r03AD = body.make_temp(glsl_type::uint_type, "zFrac0");
+ ir_variable *const r03AE = body.make_temp(glsl_type::uint_type, "zFrac1");
+ ir_variable *const r03AF = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac2", ir_var_auto);
+ body.emit(r03AF);
+ ir_variable *const r03B0 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r03B0);
+ ir_expression *const r03B1 = equal(r03A6, body.constant(0u));
+ ir_expression *const r03B2 = add(r03AC, body.constant(int(-32)));
+ body.emit(assign(r03AC, expr(ir_triop_csel, r03B1, r03B2, r03AC), 0x01));
+
+ ir_variable *const r03B3 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r03B4 = equal(r03A6, body.constant(0u));
+ body.emit(assign(r03B3, expr(ir_triop_csel, r03B4, body.constant(0u), r03A7), 0x01));
+
+ body.emit(assign(r03AE, r03B3, 0x01));
+
+ ir_variable *const r03B5 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r03B6 = equal(r03A6, body.constant(0u));
+ body.emit(assign(r03B5, expr(ir_triop_csel, r03B6, r03B3, r03A6), 0x01));
+
+ body.emit(assign(r03AD, r03B5, 0x01));
+
+ ir_expression *const r03B7 = equal(r03B5, body.constant(0u));
+ ir_expression *const r03B8 = expr(ir_unop_find_msb, r03B5);
+ ir_expression *const r03B9 = sub(body.constant(int(31)), r03B8);
+ ir_expression *const r03BA = expr(ir_triop_csel, r03B7, body.constant(int(32)), r03B9);
+ body.emit(assign(r03B0, add(r03BA, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r03BC = gequal(r03B0, body.constant(int(0)));
+ ir_if *f03BB = new(mem_ctx) ir_if(operand(r03BC).val);
+ exec_list *const f03BB_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f03BB->then_instructions;
+
+ body.emit(assign(r03AF, body.constant(0u), 0x01));
+
+ ir_expression *const r03BD = equal(r03B0, body.constant(int(0)));
+ ir_expression *const r03BE = lshift(r03B5, r03B0);
+ ir_expression *const r03BF = neg(r03B0);
+ ir_expression *const r03C0 = bit_and(r03BF, body.constant(int(31)));
+ ir_expression *const r03C1 = rshift(r03B3, r03C0);
+ ir_expression *const r03C2 = bit_or(r03BE, r03C1);
+ body.emit(assign(r03AD, expr(ir_triop_csel, r03BD, r03B5, r03C2), 0x01));
+
+ body.emit(assign(r03AE, lshift(r03B3, r03B0), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f03BB->else_instructions;
+
+ ir_variable *const r03C3 = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r03C3, neg(r03B0), 0x01));
+
+ ir_variable *const r03C4 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ ir_variable *const r03C5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r03C5);
+ ir_variable *const r03C6 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r03C7 = neg(r03C3);
+ body.emit(assign(r03C6, bit_and(r03C7, body.constant(int(31))), 0x01));
+
+ ir_variable *const r03C8 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r03C9 = less(r03C3, body.constant(int(32)));
+ ir_expression *const r03CA = bit_or(body.constant(0u), r03AE);
+ body.emit(assign(r03C8, expr(ir_triop_csel, r03C9, body.constant(0u), r03CA), 0x01));
+
+ ir_expression *const r03CB = less(r03C3, body.constant(int(32)));
+ ir_expression *const r03CC = lshift(r03AE, r03C6);
+ ir_expression *const r03CD = less(r03C3, body.constant(int(64)));
+ ir_expression *const r03CE = lshift(r03AD, r03C6);
+ ir_expression *const r03CF = equal(r03C3, body.constant(int(64)));
+ ir_expression *const r03D0 = nequal(r03AD, body.constant(0u));
+ ir_expression *const r03D1 = expr(ir_unop_b2i, r03D0);
+ ir_expression *const r03D2 = expr(ir_unop_i2u, r03D1);
+ ir_expression *const r03D3 = expr(ir_triop_csel, r03CF, r03AD, r03D2);
+ ir_expression *const r03D4 = expr(ir_triop_csel, r03CD, r03CE, r03D3);
+ ir_expression *const r03D5 = expr(ir_triop_csel, r03CB, r03CC, r03D4);
+ ir_expression *const r03D6 = nequal(r03C8, body.constant(0u));
+ ir_expression *const r03D7 = expr(ir_unop_b2i, r03D6);
+ ir_expression *const r03D8 = expr(ir_unop_i2u, r03D7);
+ body.emit(assign(r03C5, bit_or(r03D5, r03D8), 0x01));
+
+ ir_variable *const r03D9 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r03DA = equal(r03C3, body.constant(int(0)));
+ ir_expression *const r03DB = equal(r03C3, body.constant(int(32)));
+ ir_expression *const r03DC = expr(ir_triop_csel, r03DB, r03AE, r03C5);
+ body.emit(assign(r03D9, expr(ir_triop_csel, r03DA, r03C8, r03DC), 0x01));
+
+ body.emit(assign(r03C5, r03D9, 0x01));
+
+ ir_expression *const r03DD = equal(r03C3, body.constant(int(0)));
+ ir_expression *const r03DE = equal(r03C3, body.constant(int(32)));
+ ir_expression *const r03DF = less(r03C3, body.constant(int(32)));
+ ir_expression *const r03E0 = lshift(r03AD, r03C6);
+ ir_expression *const r03E1 = rshift(r03AE, r03C3);
+ ir_expression *const r03E2 = bit_or(r03E0, r03E1);
+ ir_expression *const r03E3 = less(r03C3, body.constant(int(64)));
+ ir_expression *const r03E4 = bit_and(r03C3, body.constant(int(31)));
+ ir_expression *const r03E5 = rshift(r03AD, r03E4);
+ ir_expression *const r03E6 = expr(ir_triop_csel, r03E3, r03E5, body.constant(0u));
+ ir_expression *const r03E7 = expr(ir_triop_csel, r03DF, r03E2, r03E6);
+ ir_expression *const r03E8 = expr(ir_triop_csel, r03DE, r03AD, r03E7);
+ body.emit(assign(r03C4, expr(ir_triop_csel, r03DD, r03AE, r03E8), 0x01));
+
+ ir_expression *const r03E9 = equal(r03C3, body.constant(int(0)));
+ ir_expression *const r03EA = equal(r03C3, body.constant(int(32)));
+ ir_expression *const r03EB = less(r03C3, body.constant(int(32)));
+ ir_expression *const r03EC = rshift(r03AD, r03C3);
+ ir_expression *const r03ED = expr(ir_triop_csel, r03EB, r03EC, body.constant(0u));
+ ir_expression *const r03EE = expr(ir_triop_csel, r03EA, body.constant(0u), r03ED);
+ body.emit(assign(r03AD, expr(ir_triop_csel, r03E9, r03AD, r03EE), 0x01));
+
+ body.emit(assign(r03AE, r03C4, 0x01));
+
+ body.emit(assign(r03AF, r03D9, 0x01));
+
+
+ body.instructions = f03BB_parent_instructions;
+ body.emit(f03BB);
+
+ /* END IF */
+
+ body.emit(assign(r03AC, sub(r03AC, r03B0), 0x01));
+
+ ir_variable *const r03EF = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r03EF, r03AC, 0x01));
+
+ ir_variable *const r03F0 = body.make_temp(glsl_type::uint_type, "zFrac0");
+ body.emit(assign(r03F0, r03AD, 0x01));
+
+ ir_variable *const r03F1 = body.make_temp(glsl_type::uint_type, "zFrac1");
+ body.emit(assign(r03F1, r03AE, 0x01));
+
+ ir_variable *const r03F2 = body.make_temp(glsl_type::uint_type, "zFrac2");
+ body.emit(assign(r03F2, r03AF, 0x01));
+
+ ir_variable *const r03F3 = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r03F3, body.constant(true), 0x01));
+
+ ir_variable *const r03F4 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r03F5 = new(mem_ctx) ir_variable(glsl_type::bool_type, "increment", ir_var_auto);
+ body.emit(r03F5);
+ ir_expression *const r03F6 = expr(ir_unop_u2i, r03AF);
+ body.emit(assign(r03F5, less(r03F6, body.constant(int(0))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r03F8 = gequal(r03AC, body.constant(int(2045)));
+ ir_if *f03F7 = new(mem_ctx) ir_if(operand(r03F8).val);
+ exec_list *const f03F7_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f03F7->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r03FA = less(body.constant(int(2045)), r03AC);
+ ir_expression *const r03FB = equal(r03AC, body.constant(int(2045)));
+ ir_expression *const r03FC = equal(body.constant(2097151u), r03AD);
+ ir_expression *const r03FD = equal(body.constant(4294967295u), r03AE);
+ ir_expression *const r03FE = logic_and(r03FC, r03FD);
+ ir_expression *const r03FF = logic_and(r03FB, r03FE);
+ ir_expression *const r0400 = logic_and(r03FF, r03F5);
+ ir_expression *const r0401 = logic_or(r03FA, r0400);
+ ir_if *f03F9 = new(mem_ctx) ir_if(operand(r0401).val);
+ exec_list *const f03F9_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f03F9->then_instructions;
+
+ ir_variable *const r0402 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0402);
+ ir_expression *const r0403 = lshift(r021A, body.constant(int(31)));
+ body.emit(assign(r0402, add(r0403, body.constant(2146435072u)), 0x02));
+
+ body.emit(assign(r0402, body.constant(0u), 0x01));
+
+ body.emit(assign(r03F4, r0402, 0x03));
+
+ body.emit(assign(r03F3, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f03F9->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0405 = less(r03AC, body.constant(int(0)));
+ ir_if *f0404 = new(mem_ctx) ir_if(operand(r0405).val);
+ exec_list *const f0404_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0404->then_instructions;
+
+ ir_variable *const r0406 = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r0406, neg(r03AC), 0x01));
+
+ ir_variable *const r0407 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r0407);
+ ir_variable *const r0408 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r0409 = neg(r0406);
+ body.emit(assign(r0408, bit_and(r0409, body.constant(int(31))), 0x01));
+
+ ir_variable *const r040A = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r040B = less(r0406, body.constant(int(32)));
+ ir_expression *const r040C = bit_or(r03AF, r03AE);
+ body.emit(assign(r040A, expr(ir_triop_csel, r040B, r03AF, r040C), 0x01));
+
+ ir_expression *const r040D = less(r0406, body.constant(int(32)));
+ ir_expression *const r040E = lshift(r03AE, r0408);
+ ir_expression *const r040F = less(r0406, body.constant(int(64)));
+ ir_expression *const r0410 = lshift(r03AD, r0408);
+ ir_expression *const r0411 = equal(r0406, body.constant(int(64)));
+ ir_expression *const r0412 = nequal(r03AD, body.constant(0u));
+ ir_expression *const r0413 = expr(ir_unop_b2i, r0412);
+ ir_expression *const r0414 = expr(ir_unop_i2u, r0413);
+ ir_expression *const r0415 = expr(ir_triop_csel, r0411, r03AD, r0414);
+ ir_expression *const r0416 = expr(ir_triop_csel, r040F, r0410, r0415);
+ ir_expression *const r0417 = expr(ir_triop_csel, r040D, r040E, r0416);
+ ir_expression *const r0418 = nequal(r040A, body.constant(0u));
+ ir_expression *const r0419 = expr(ir_unop_b2i, r0418);
+ ir_expression *const r041A = expr(ir_unop_i2u, r0419);
+ body.emit(assign(r0407, bit_or(r0417, r041A), 0x01));
+
+ ir_variable *const r041B = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r041C = equal(r0406, body.constant(int(0)));
+ ir_expression *const r041D = equal(r0406, body.constant(int(32)));
+ ir_expression *const r041E = expr(ir_triop_csel, r041D, r03AE, r0407);
+ body.emit(assign(r041B, expr(ir_triop_csel, r041C, r040A, r041E), 0x01));
+
+ body.emit(assign(r0407, r041B, 0x01));
+
+ ir_expression *const r041F = equal(r0406, body.constant(int(0)));
+ ir_expression *const r0420 = equal(r0406, body.constant(int(32)));
+ ir_expression *const r0421 = less(r0406, body.constant(int(32)));
+ ir_expression *const r0422 = rshift(r03AD, r0406);
+ ir_expression *const r0423 = expr(ir_triop_csel, r0421, r0422, body.constant(0u));
+ ir_expression *const r0424 = expr(ir_triop_csel, r0420, body.constant(0u), r0423);
+ body.emit(assign(r03F0, expr(ir_triop_csel, r041F, r03AD, r0424), 0x01));
+
+ ir_expression *const r0425 = equal(r0406, body.constant(int(0)));
+ ir_expression *const r0426 = equal(r0406, body.constant(int(32)));
+ ir_expression *const r0427 = less(r0406, body.constant(int(32)));
+ ir_expression *const r0428 = lshift(r03AD, r0408);
+ ir_expression *const r0429 = rshift(r03AE, r0406);
+ ir_expression *const r042A = bit_or(r0428, r0429);
+ ir_expression *const r042B = less(r0406, body.constant(int(64)));
+ ir_expression *const r042C = bit_and(r0406, body.constant(int(31)));
+ ir_expression *const r042D = rshift(r03AD, r042C);
+ ir_expression *const r042E = expr(ir_triop_csel, r042B, r042D, body.constant(0u));
+ ir_expression *const r042F = expr(ir_triop_csel, r0427, r042A, r042E);
+ ir_expression *const r0430 = expr(ir_triop_csel, r0426, r03AD, r042F);
+ body.emit(assign(r03F1, expr(ir_triop_csel, r0425, r03AE, r0430), 0x01));
+
+ body.emit(assign(r03F2, r041B, 0x01));
+
+ body.emit(assign(r03EF, body.constant(int(0)), 0x01));
+
+ body.emit(assign(r03F5, less(r041B, body.constant(0u)), 0x01));
+
+
+ body.instructions = f0404_parent_instructions;
+ body.emit(f0404);
+
+ /* END IF */
+
+
+ body.instructions = f03F9_parent_instructions;
+ body.emit(f03F9);
+
+ /* END IF */
+
+
+ body.instructions = f03F7_parent_instructions;
+ body.emit(f03F7);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f0431 = new(mem_ctx) ir_if(operand(r03F3).val);
+ exec_list *const f0431_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0431->then_instructions;
+
+ /* IF CONDITION */
+ ir_if *f0432 = new(mem_ctx) ir_if(operand(r03F5).val);
+ exec_list *const f0432_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0432->then_instructions;
+
+ ir_variable *const r0433 = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r0433, add(r03F1, body.constant(1u)), 0x01));
+
+ ir_expression *const r0434 = less(r0433, r03F1);
+ ir_expression *const r0435 = expr(ir_unop_b2i, r0434);
+ ir_expression *const r0436 = expr(ir_unop_i2u, r0435);
+ body.emit(assign(r03F0, add(r03F0, r0436), 0x01));
+
+ ir_expression *const r0437 = equal(r03F2, body.constant(0u));
+ ir_expression *const r0438 = expr(ir_unop_b2i, r0437);
+ ir_expression *const r0439 = expr(ir_unop_i2u, r0438);
+ ir_expression *const r043A = add(r03F2, r0439);
+ ir_expression *const r043B = bit_and(r043A, body.constant(1u));
+ ir_expression *const r043C = expr(ir_unop_bit_not, r043B);
+ body.emit(assign(r03F1, bit_and(r0433, r043C), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0432->else_instructions;
+
+ ir_expression *const r043D = bit_or(r03F0, r03F1);
+ ir_expression *const r043E = equal(r043D, body.constant(0u));
+ body.emit(assign(r03EF, expr(ir_triop_csel, r043E, body.constant(int(0)), r03EF), 0x01));
+
+
+ body.instructions = f0432_parent_instructions;
+ body.emit(f0432);
+
+ /* END IF */
+
+ ir_variable *const r043F = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r043F);
+ ir_expression *const r0440 = lshift(r021A, body.constant(int(31)));
+ ir_expression *const r0441 = expr(ir_unop_i2u, r03EF);
+ ir_expression *const r0442 = lshift(r0441, body.constant(int(20)));
+ ir_expression *const r0443 = add(r0440, r0442);
+ body.emit(assign(r043F, add(r0443, r03F0), 0x02));
+
+ body.emit(assign(r043F, r03F1, 0x01));
+
+ body.emit(assign(r03F4, r043F, 0x03));
+
+ body.emit(assign(r03F3, body.constant(false), 0x01));
+
+
+ body.instructions = f0431_parent_instructions;
+ body.emit(f0431);
+
+ /* END IF */
+
+ body.emit(assign(r020F, r03F4, 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ body.instructions = f0360_parent_instructions;
+ body.emit(f0360);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f035E->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0445 = less(r0210, body.constant(int(0)));
+ ir_if *f0444 = new(mem_ctx) ir_if(operand(r0445).val);
+ exec_list *const f0444_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0444->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0447 = equal(r0221, body.constant(int(2047)));
+ ir_if *f0446 = new(mem_ctx) ir_if(operand(r0447).val);
+ exec_list *const f0446_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0446->then_instructions;
+
+ ir_variable *const r0448 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0448);
+ ir_expression *const r0449 = bit_xor(r021A, body.constant(1u));
+ ir_expression *const r044A = lshift(r0449, body.constant(int(31)));
+ body.emit(assign(r0448, add(r044A, body.constant(2146435072u)), 0x02));
+
+ body.emit(assign(r0448, body.constant(0u), 0x01));
+
+ ir_variable *const r044B = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r044B, swizzle_x(r020C), 0x01));
+
+ ir_variable *const r044C = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r044C, swizzle_x(r020D), 0x01));
+
+ body.emit(assign(r044B, bit_or(swizzle_y(r020C), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r044C, bit_or(swizzle_y(r020D), body.constant(524288u)), 0x02));
+
+ ir_expression *const r044D = bit_or(r0215, r0216);
+ ir_expression *const r044E = nequal(r044D, body.constant(0u));
+ ir_swizzle *const r044F = swizzle(r044E, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0450 = lshift(swizzle_y(r020C), body.constant(int(1)));
+ ir_expression *const r0451 = gequal(r0450, body.constant(4292870144u));
+ ir_expression *const r0452 = nequal(swizzle_x(r020C), body.constant(0u));
+ ir_expression *const r0453 = bit_and(swizzle_y(r020C), body.constant(1048575u));
+ ir_expression *const r0454 = nequal(r0453, body.constant(0u));
+ ir_expression *const r0455 = logic_or(r0452, r0454);
+ ir_expression *const r0456 = logic_and(r0451, r0455);
+ ir_swizzle *const r0457 = swizzle(r0456, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0458 = lshift(swizzle_y(r020D), body.constant(int(1)));
+ ir_expression *const r0459 = gequal(r0458, body.constant(4292870144u));
+ ir_expression *const r045A = nequal(swizzle_x(r020D), body.constant(0u));
+ ir_expression *const r045B = bit_and(swizzle_y(r020D), body.constant(1048575u));
+ ir_expression *const r045C = nequal(r045B, body.constant(0u));
+ ir_expression *const r045D = logic_or(r045A, r045C);
+ ir_expression *const r045E = logic_and(r0459, r045D);
+ ir_swizzle *const r045F = swizzle(r045E, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0460 = expr(ir_triop_csel, r045F, r044C, r044B);
+ ir_expression *const r0461 = expr(ir_triop_csel, r0457, r0460, r044C);
+ body.emit(assign(r020F, expr(ir_triop_csel, r044F, r0461, r0448), 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0446->else_instructions;
+
+ ir_variable *const r0462 = body.make_temp(glsl_type::int_type, "mix_retval");
+ ir_expression *const r0463 = equal(r021E, body.constant(int(0)));
+ ir_expression *const r0464 = add(r0210, body.constant(int(1)));
+ body.emit(assign(r0462, expr(ir_triop_csel, r0463, r0464, r0210), 0x01));
+
+ body.emit(assign(r0210, r0462, 0x01));
+
+ ir_variable *const r0465 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0466 = equal(r021E, body.constant(int(0)));
+ ir_expression *const r0467 = bit_or(r0217, body.constant(1073741824u));
+ body.emit(assign(r0465, expr(ir_triop_csel, r0466, r0217, r0467), 0x01));
+
+ ir_variable *const r0468 = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r0468, neg(r0462), 0x01));
+
+ ir_variable *const r0469 = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r046A = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r046A);
+ ir_variable *const r046B = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r046C = neg(r0468);
+ body.emit(assign(r046B, bit_and(r046C, body.constant(int(31))), 0x01));
+
+ ir_expression *const r046D = bit_or(r0465, r0357);
+ ir_expression *const r046E = nequal(r046D, body.constant(0u));
+ ir_expression *const r046F = expr(ir_unop_b2i, r046E);
+ body.emit(assign(r046A, expr(ir_unop_i2u, r046F), 0x01));
+
+ ir_variable *const r0470 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0471 = equal(r0468, body.constant(int(0)));
+ ir_expression *const r0472 = less(r0468, body.constant(int(32)));
+ ir_expression *const r0473 = lshift(r0465, r046B);
+ ir_expression *const r0474 = rshift(r0357, r0468);
+ ir_expression *const r0475 = bit_or(r0473, r0474);
+ ir_expression *const r0476 = lshift(r0357, r046B);
+ ir_expression *const r0477 = nequal(r0476, body.constant(0u));
+ ir_expression *const r0478 = expr(ir_unop_b2i, r0477);
+ ir_expression *const r0479 = expr(ir_unop_i2u, r0478);
+ ir_expression *const r047A = bit_or(r0475, r0479);
+ ir_expression *const r047B = equal(r0468, body.constant(int(32)));
+ ir_expression *const r047C = nequal(r0357, body.constant(0u));
+ ir_expression *const r047D = expr(ir_unop_b2i, r047C);
+ ir_expression *const r047E = expr(ir_unop_i2u, r047D);
+ ir_expression *const r047F = bit_or(r0465, r047E);
+ ir_expression *const r0480 = less(r0468, body.constant(int(64)));
+ ir_expression *const r0481 = bit_and(r0468, body.constant(int(31)));
+ ir_expression *const r0482 = rshift(r0465, r0481);
+ ir_expression *const r0483 = lshift(r0465, r046B);
+ ir_expression *const r0484 = bit_or(r0483, r0357);
+ ir_expression *const r0485 = nequal(r0484, body.constant(0u));
+ ir_expression *const r0486 = expr(ir_unop_b2i, r0485);
+ ir_expression *const r0487 = expr(ir_unop_i2u, r0486);
+ ir_expression *const r0488 = bit_or(r0482, r0487);
+ ir_expression *const r0489 = expr(ir_triop_csel, r0480, r0488, r046A);
+ ir_expression *const r048A = expr(ir_triop_csel, r047B, r047F, r0489);
+ ir_expression *const r048B = expr(ir_triop_csel, r0472, r047A, r048A);
+ body.emit(assign(r0470, expr(ir_triop_csel, r0471, r0357, r048B), 0x01));
+
+ body.emit(assign(r046A, r0470, 0x01));
+
+ ir_expression *const r048C = less(r0468, body.constant(int(32)));
+ ir_expression *const r048D = rshift(r0465, r0468);
+ ir_expression *const r048E = equal(r0468, body.constant(int(0)));
+ ir_expression *const r048F = expr(ir_triop_csel, r048E, r0465, body.constant(0u));
+ body.emit(assign(r0469, expr(ir_triop_csel, r048C, r048D, r048F), 0x01));
+
+ body.emit(assign(r0217, r0469, 0x01));
+
+ body.emit(assign(r0218, r0470, 0x01));
+
+ body.emit(assign(r0215, bit_or(r0215, body.constant(1073741824u)), 0x01));
+
+ ir_variable *const r0490 = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r0491 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r0491, sub(r0216, r0470), 0x01));
+
+ ir_expression *const r0492 = sub(r0215, r0469);
+ ir_expression *const r0493 = less(r0216, r0470);
+ ir_expression *const r0494 = expr(ir_unop_b2i, r0493);
+ ir_expression *const r0495 = expr(ir_unop_i2u, r0494);
+ body.emit(assign(r0490, sub(r0492, r0495), 0x01));
+
+ body.emit(assign(r0212, r0490, 0x01));
+
+ body.emit(assign(r0211, r0491, 0x01));
+
+ body.emit(assign(r0219, bit_xor(r021A, body.constant(1u)), 0x01));
+
+ body.emit(assign(r0355, add(r0221, body.constant(int(-1))), 0x01));
+
+ ir_variable *const r0496 = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r0496, add(r0355, body.constant(int(-10))), 0x01));
+
+ ir_variable *const r0497 = body.make_temp(glsl_type::uint_type, "zFrac0");
+ ir_variable *const r0498 = body.make_temp(glsl_type::uint_type, "zFrac1");
+ ir_variable *const r0499 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac2", ir_var_auto);
+ body.emit(r0499);
+ ir_variable *const r049A = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r049A);
+ ir_expression *const r049B = equal(r0490, body.constant(0u));
+ ir_expression *const r049C = add(r0496, body.constant(int(-32)));
+ body.emit(assign(r0496, expr(ir_triop_csel, r049B, r049C, r0496), 0x01));
+
+ ir_variable *const r049D = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r049E = equal(r0490, body.constant(0u));
+ body.emit(assign(r049D, expr(ir_triop_csel, r049E, body.constant(0u), r0491), 0x01));
+
+ body.emit(assign(r0498, r049D, 0x01));
+
+ ir_variable *const r049F = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r04A0 = equal(r0490, body.constant(0u));
+ body.emit(assign(r049F, expr(ir_triop_csel, r04A0, r049D, r0490), 0x01));
+
+ body.emit(assign(r0497, r049F, 0x01));
+
+ ir_expression *const r04A1 = equal(r049F, body.constant(0u));
+ ir_expression *const r04A2 = expr(ir_unop_find_msb, r049F);
+ ir_expression *const r04A3 = sub(body.constant(int(31)), r04A2);
+ ir_expression *const r04A4 = expr(ir_triop_csel, r04A1, body.constant(int(32)), r04A3);
+ body.emit(assign(r049A, add(r04A4, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r04A6 = gequal(r049A, body.constant(int(0)));
+ ir_if *f04A5 = new(mem_ctx) ir_if(operand(r04A6).val);
+ exec_list *const f04A5_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f04A5->then_instructions;
+
+ body.emit(assign(r0499, body.constant(0u), 0x01));
+
+ ir_expression *const r04A7 = equal(r049A, body.constant(int(0)));
+ ir_expression *const r04A8 = lshift(r049F, r049A);
+ ir_expression *const r04A9 = neg(r049A);
+ ir_expression *const r04AA = bit_and(r04A9, body.constant(int(31)));
+ ir_expression *const r04AB = rshift(r049D, r04AA);
+ ir_expression *const r04AC = bit_or(r04A8, r04AB);
+ body.emit(assign(r0497, expr(ir_triop_csel, r04A7, r049F, r04AC), 0x01));
+
+ body.emit(assign(r0498, lshift(r049D, r049A), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f04A5->else_instructions;
+
+ ir_variable *const r04AD = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r04AD, neg(r049A), 0x01));
+
+ ir_variable *const r04AE = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ ir_variable *const r04AF = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r04AF);
+ ir_variable *const r04B0 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r04B1 = neg(r04AD);
+ body.emit(assign(r04B0, bit_and(r04B1, body.constant(int(31))), 0x01));
+
+ ir_variable *const r04B2 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r04B3 = less(r04AD, body.constant(int(32)));
+ ir_expression *const r04B4 = bit_or(body.constant(0u), r0498);
+ body.emit(assign(r04B2, expr(ir_triop_csel, r04B3, body.constant(0u), r04B4), 0x01));
+
+ ir_expression *const r04B5 = less(r04AD, body.constant(int(32)));
+ ir_expression *const r04B6 = lshift(r0498, r04B0);
+ ir_expression *const r04B7 = less(r04AD, body.constant(int(64)));
+ ir_expression *const r04B8 = lshift(r0497, r04B0);
+ ir_expression *const r04B9 = equal(r04AD, body.constant(int(64)));
+ ir_expression *const r04BA = nequal(r0497, body.constant(0u));
+ ir_expression *const r04BB = expr(ir_unop_b2i, r04BA);
+ ir_expression *const r04BC = expr(ir_unop_i2u, r04BB);
+ ir_expression *const r04BD = expr(ir_triop_csel, r04B9, r0497, r04BC);
+ ir_expression *const r04BE = expr(ir_triop_csel, r04B7, r04B8, r04BD);
+ ir_expression *const r04BF = expr(ir_triop_csel, r04B5, r04B6, r04BE);
+ ir_expression *const r04C0 = nequal(r04B2, body.constant(0u));
+ ir_expression *const r04C1 = expr(ir_unop_b2i, r04C0);
+ ir_expression *const r04C2 = expr(ir_unop_i2u, r04C1);
+ body.emit(assign(r04AF, bit_or(r04BF, r04C2), 0x01));
+
+ ir_variable *const r04C3 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r04C4 = equal(r04AD, body.constant(int(0)));
+ ir_expression *const r04C5 = equal(r04AD, body.constant(int(32)));
+ ir_expression *const r04C6 = expr(ir_triop_csel, r04C5, r0498, r04AF);
+ body.emit(assign(r04C3, expr(ir_triop_csel, r04C4, r04B2, r04C6), 0x01));
+
+ body.emit(assign(r04AF, r04C3, 0x01));
+
+ ir_expression *const r04C7 = equal(r04AD, body.constant(int(0)));
+ ir_expression *const r04C8 = equal(r04AD, body.constant(int(32)));
+ ir_expression *const r04C9 = less(r04AD, body.constant(int(32)));
+ ir_expression *const r04CA = lshift(r0497, r04B0);
+ ir_expression *const r04CB = rshift(r0498, r04AD);
+ ir_expression *const r04CC = bit_or(r04CA, r04CB);
+ ir_expression *const r04CD = less(r04AD, body.constant(int(64)));
+ ir_expression *const r04CE = bit_and(r04AD, body.constant(int(31)));
+ ir_expression *const r04CF = rshift(r0497, r04CE);
+ ir_expression *const r04D0 = expr(ir_triop_csel, r04CD, r04CF, body.constant(0u));
+ ir_expression *const r04D1 = expr(ir_triop_csel, r04C9, r04CC, r04D0);
+ ir_expression *const r04D2 = expr(ir_triop_csel, r04C8, r0497, r04D1);
+ body.emit(assign(r04AE, expr(ir_triop_csel, r04C7, r0498, r04D2), 0x01));
+
+ ir_expression *const r04D3 = equal(r04AD, body.constant(int(0)));
+ ir_expression *const r04D4 = equal(r04AD, body.constant(int(32)));
+ ir_expression *const r04D5 = less(r04AD, body.constant(int(32)));
+ ir_expression *const r04D6 = rshift(r0497, r04AD);
+ ir_expression *const r04D7 = expr(ir_triop_csel, r04D5, r04D6, body.constant(0u));
+ ir_expression *const r04D8 = expr(ir_triop_csel, r04D4, body.constant(0u), r04D7);
+ body.emit(assign(r0497, expr(ir_triop_csel, r04D3, r0497, r04D8), 0x01));
+
+ body.emit(assign(r0498, r04AE, 0x01));
+
+ body.emit(assign(r0499, r04C3, 0x01));
+
+
+ body.instructions = f04A5_parent_instructions;
+ body.emit(f04A5);
+
+ /* END IF */
+
+ body.emit(assign(r0496, sub(r0496, r049A), 0x01));
+
+ ir_variable *const r04D9 = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r04D9, r0496, 0x01));
+
+ ir_variable *const r04DA = body.make_temp(glsl_type::uint_type, "zFrac0");
+ body.emit(assign(r04DA, r0497, 0x01));
+
+ ir_variable *const r04DB = body.make_temp(glsl_type::uint_type, "zFrac1");
+ body.emit(assign(r04DB, r0498, 0x01));
+
+ ir_variable *const r04DC = body.make_temp(glsl_type::uint_type, "zFrac2");
+ body.emit(assign(r04DC, r0499, 0x01));
+
+ ir_variable *const r04DD = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r04DD, body.constant(true), 0x01));
+
+ ir_variable *const r04DE = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r04DF = new(mem_ctx) ir_variable(glsl_type::bool_type, "increment", ir_var_auto);
+ body.emit(r04DF);
+ ir_expression *const r04E0 = expr(ir_unop_u2i, r0499);
+ body.emit(assign(r04DF, less(r04E0, body.constant(int(0))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r04E2 = gequal(r0496, body.constant(int(2045)));
+ ir_if *f04E1 = new(mem_ctx) ir_if(operand(r04E2).val);
+ exec_list *const f04E1_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f04E1->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r04E4 = less(body.constant(int(2045)), r0496);
+ ir_expression *const r04E5 = equal(r0496, body.constant(int(2045)));
+ ir_expression *const r04E6 = equal(body.constant(2097151u), r0497);
+ ir_expression *const r04E7 = equal(body.constant(4294967295u), r0498);
+ ir_expression *const r04E8 = logic_and(r04E6, r04E7);
+ ir_expression *const r04E9 = logic_and(r04E5, r04E8);
+ ir_expression *const r04EA = logic_and(r04E9, r04DF);
+ ir_expression *const r04EB = logic_or(r04E4, r04EA);
+ ir_if *f04E3 = new(mem_ctx) ir_if(operand(r04EB).val);
+ exec_list *const f04E3_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f04E3->then_instructions;
+
+ ir_variable *const r04EC = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r04EC);
+ ir_expression *const r04ED = lshift(r0219, body.constant(int(31)));
+ body.emit(assign(r04EC, add(r04ED, body.constant(2146435072u)), 0x02));
+
+ body.emit(assign(r04EC, body.constant(0u), 0x01));
+
+ body.emit(assign(r04DE, r04EC, 0x03));
+
+ body.emit(assign(r04DD, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f04E3->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r04EF = less(r0496, body.constant(int(0)));
+ ir_if *f04EE = new(mem_ctx) ir_if(operand(r04EF).val);
+ exec_list *const f04EE_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f04EE->then_instructions;
+
+ ir_variable *const r04F0 = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r04F0, neg(r0496), 0x01));
+
+ ir_variable *const r04F1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r04F1);
+ ir_variable *const r04F2 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r04F3 = neg(r04F0);
+ body.emit(assign(r04F2, bit_and(r04F3, body.constant(int(31))), 0x01));
+
+ ir_variable *const r04F4 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r04F5 = less(r04F0, body.constant(int(32)));
+ ir_expression *const r04F6 = bit_or(r0499, r0498);
+ body.emit(assign(r04F4, expr(ir_triop_csel, r04F5, r0499, r04F6), 0x01));
+
+ ir_expression *const r04F7 = less(r04F0, body.constant(int(32)));
+ ir_expression *const r04F8 = lshift(r0498, r04F2);
+ ir_expression *const r04F9 = less(r04F0, body.constant(int(64)));
+ ir_expression *const r04FA = lshift(r0497, r04F2);
+ ir_expression *const r04FB = equal(r04F0, body.constant(int(64)));
+ ir_expression *const r04FC = nequal(r0497, body.constant(0u));
+ ir_expression *const r04FD = expr(ir_unop_b2i, r04FC);
+ ir_expression *const r04FE = expr(ir_unop_i2u, r04FD);
+ ir_expression *const r04FF = expr(ir_triop_csel, r04FB, r0497, r04FE);
+ ir_expression *const r0500 = expr(ir_triop_csel, r04F9, r04FA, r04FF);
+ ir_expression *const r0501 = expr(ir_triop_csel, r04F7, r04F8, r0500);
+ ir_expression *const r0502 = nequal(r04F4, body.constant(0u));
+ ir_expression *const r0503 = expr(ir_unop_b2i, r0502);
+ ir_expression *const r0504 = expr(ir_unop_i2u, r0503);
+ body.emit(assign(r04F1, bit_or(r0501, r0504), 0x01));
+
+ ir_variable *const r0505 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0506 = equal(r04F0, body.constant(int(0)));
+ ir_expression *const r0507 = equal(r04F0, body.constant(int(32)));
+ ir_expression *const r0508 = expr(ir_triop_csel, r0507, r0498, r04F1);
+ body.emit(assign(r0505, expr(ir_triop_csel, r0506, r04F4, r0508), 0x01));
+
+ body.emit(assign(r04F1, r0505, 0x01));
+
+ ir_expression *const r0509 = equal(r04F0, body.constant(int(0)));
+ ir_expression *const r050A = equal(r04F0, body.constant(int(32)));
+ ir_expression *const r050B = less(r04F0, body.constant(int(32)));
+ ir_expression *const r050C = rshift(r0497, r04F0);
+ ir_expression *const r050D = expr(ir_triop_csel, r050B, r050C, body.constant(0u));
+ ir_expression *const r050E = expr(ir_triop_csel, r050A, body.constant(0u), r050D);
+ body.emit(assign(r04DA, expr(ir_triop_csel, r0509, r0497, r050E), 0x01));
+
+ ir_expression *const r050F = equal(r04F0, body.constant(int(0)));
+ ir_expression *const r0510 = equal(r04F0, body.constant(int(32)));
+ ir_expression *const r0511 = less(r04F0, body.constant(int(32)));
+ ir_expression *const r0512 = lshift(r0497, r04F2);
+ ir_expression *const r0513 = rshift(r0498, r04F0);
+ ir_expression *const r0514 = bit_or(r0512, r0513);
+ ir_expression *const r0515 = less(r04F0, body.constant(int(64)));
+ ir_expression *const r0516 = bit_and(r04F0, body.constant(int(31)));
+ ir_expression *const r0517 = rshift(r0497, r0516);
+ ir_expression *const r0518 = expr(ir_triop_csel, r0515, r0517, body.constant(0u));
+ ir_expression *const r0519 = expr(ir_triop_csel, r0511, r0514, r0518);
+ ir_expression *const r051A = expr(ir_triop_csel, r0510, r0497, r0519);
+ body.emit(assign(r04DB, expr(ir_triop_csel, r050F, r0498, r051A), 0x01));
+
+ body.emit(assign(r04DC, r0505, 0x01));
+
+ body.emit(assign(r04D9, body.constant(int(0)), 0x01));
+
+ body.emit(assign(r04DF, less(r0505, body.constant(0u)), 0x01));
+
+
+ body.instructions = f04EE_parent_instructions;
+ body.emit(f04EE);
+
+ /* END IF */
+
+
+ body.instructions = f04E3_parent_instructions;
+ body.emit(f04E3);
+
+ /* END IF */
+
+
+ body.instructions = f04E1_parent_instructions;
+ body.emit(f04E1);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f051B = new(mem_ctx) ir_if(operand(r04DD).val);
+ exec_list *const f051B_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f051B->then_instructions;
+
+ /* IF CONDITION */
+ ir_if *f051C = new(mem_ctx) ir_if(operand(r04DF).val);
+ exec_list *const f051C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f051C->then_instructions;
+
+ ir_variable *const r051D = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r051D, add(r04DB, body.constant(1u)), 0x01));
+
+ ir_expression *const r051E = less(r051D, r04DB);
+ ir_expression *const r051F = expr(ir_unop_b2i, r051E);
+ ir_expression *const r0520 = expr(ir_unop_i2u, r051F);
+ body.emit(assign(r04DA, add(r04DA, r0520), 0x01));
+
+ ir_expression *const r0521 = equal(r04DC, body.constant(0u));
+ ir_expression *const r0522 = expr(ir_unop_b2i, r0521);
+ ir_expression *const r0523 = expr(ir_unop_i2u, r0522);
+ ir_expression *const r0524 = add(r04DC, r0523);
+ ir_expression *const r0525 = bit_and(r0524, body.constant(1u));
+ ir_expression *const r0526 = expr(ir_unop_bit_not, r0525);
+ body.emit(assign(r04DB, bit_and(r051D, r0526), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f051C->else_instructions;
+
+ ir_expression *const r0527 = bit_or(r04DA, r04DB);
+ ir_expression *const r0528 = equal(r0527, body.constant(0u));
+ body.emit(assign(r04D9, expr(ir_triop_csel, r0528, body.constant(int(0)), r04D9), 0x01));
+
+
+ body.instructions = f051C_parent_instructions;
+ body.emit(f051C);
+
+ /* END IF */
+
+ ir_variable *const r0529 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0529);
+ ir_expression *const r052A = lshift(r0219, body.constant(int(31)));
+ ir_expression *const r052B = expr(ir_unop_i2u, r04D9);
+ ir_expression *const r052C = lshift(r052B, body.constant(int(20)));
+ ir_expression *const r052D = add(r052A, r052C);
+ body.emit(assign(r0529, add(r052D, r04DA), 0x02));
+
+ body.emit(assign(r0529, r04DB, 0x01));
+
+ body.emit(assign(r04DE, r0529, 0x03));
+
+ body.emit(assign(r04DD, body.constant(false), 0x01));
+
+
+ body.instructions = f051B_parent_instructions;
+ body.emit(f051B);
+
+ /* END IF */
+
+ body.emit(assign(r020F, r04DE, 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ body.instructions = f0446_parent_instructions;
+ body.emit(f0446);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0444->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r052F = equal(r021E, body.constant(int(2047)));
+ ir_if *f052E = new(mem_ctx) ir_if(operand(r052F).val);
+ exec_list *const f052E_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f052E->then_instructions;
+
+ ir_variable *const r0530 = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r0530, swizzle_x(r020C), 0x01));
+
+ ir_variable *const r0531 = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r0531, swizzle_x(r020D), 0x01));
+
+ body.emit(assign(r0530, bit_or(swizzle_y(r020C), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r0531, bit_or(swizzle_y(r020D), body.constant(524288u)), 0x02));
+
+ ir_expression *const r0532 = bit_or(r0217, r0218);
+ ir_expression *const r0533 = bit_or(r0215, r0216);
+ ir_expression *const r0534 = bit_or(r0532, r0533);
+ ir_expression *const r0535 = nequal(r0534, body.constant(0u));
+ ir_swizzle *const r0536 = swizzle(r0535, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0537 = lshift(swizzle_y(r020C), body.constant(int(1)));
+ ir_expression *const r0538 = gequal(r0537, body.constant(4292870144u));
+ ir_expression *const r0539 = nequal(swizzle_x(r020C), body.constant(0u));
+ ir_expression *const r053A = bit_and(swizzle_y(r020C), body.constant(1048575u));
+ ir_expression *const r053B = nequal(r053A, body.constant(0u));
+ ir_expression *const r053C = logic_or(r0539, r053B);
+ ir_expression *const r053D = logic_and(r0538, r053C);
+ ir_swizzle *const r053E = swizzle(r053D, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r053F = lshift(swizzle_y(r020D), body.constant(int(1)));
+ ir_expression *const r0540 = gequal(r053F, body.constant(4292870144u));
+ ir_expression *const r0541 = nequal(swizzle_x(r020D), body.constant(0u));
+ ir_expression *const r0542 = bit_and(swizzle_y(r020D), body.constant(1048575u));
+ ir_expression *const r0543 = nequal(r0542, body.constant(0u));
+ ir_expression *const r0544 = logic_or(r0541, r0543);
+ ir_expression *const r0545 = logic_and(r0540, r0544);
+ ir_swizzle *const r0546 = swizzle(r0545, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ ir_expression *const r0547 = expr(ir_triop_csel, r0546, r0531, r0530);
+ ir_expression *const r0548 = expr(ir_triop_csel, r053E, r0547, r0531);
+ ir_constant_data r0549_data;
+ memset(&r0549_data, 0, sizeof(ir_constant_data));
+ r0549_data.u[0] = 4294967295;
+ r0549_data.u[1] = 4294967295;
+ ir_constant *const r0549 = new(mem_ctx) ir_constant(glsl_type::uvec2_type, &r0549_data);
+ body.emit(assign(r020F, expr(ir_triop_csel, r0536, r0548, r0549), 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f052E->else_instructions;
+
+ ir_expression *const r054A = equal(r021E, body.constant(int(0)));
+ body.emit(assign(r0213, expr(ir_triop_csel, r054A, body.constant(int(1)), r0221), 0x01));
+
+ ir_expression *const r054B = equal(r021E, body.constant(int(0)));
+ body.emit(assign(r0214, expr(ir_triop_csel, r054B, body.constant(int(1)), r021E), 0x01));
+
+ body.emit(assign(r0354, body.constant(false), 0x01));
+
+ body.emit(assign(r0353, body.constant(true), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r054D = less(r0215, r0217);
+ ir_if *f054C = new(mem_ctx) ir_if(operand(r054D).val);
+ exec_list *const f054C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f054C->then_instructions;
+
+ ir_expression *const r054E = sub(r0217, r0215);
+ ir_expression *const r054F = less(r0218, r0216);
+ ir_expression *const r0550 = expr(ir_unop_b2i, r054F);
+ ir_expression *const r0551 = expr(ir_unop_i2u, r0550);
+ body.emit(assign(r0212, sub(r054E, r0551), 0x01));
+
+ body.emit(assign(r0211, sub(r0218, r0216), 0x01));
+
+ body.emit(assign(r0354, body.constant(true), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f054C->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0553 = less(r0217, r0215);
+ ir_if *f0552 = new(mem_ctx) ir_if(operand(r0553).val);
+ exec_list *const f0552_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0552->then_instructions;
+
+ ir_expression *const r0554 = sub(r0215, r0217);
+ ir_expression *const r0555 = less(r0216, r0218);
+ ir_expression *const r0556 = expr(ir_unop_b2i, r0555);
+ ir_expression *const r0557 = expr(ir_unop_i2u, r0556);
+ body.emit(assign(r0212, sub(r0554, r0557), 0x01));
+
+ body.emit(assign(r0211, sub(r0216, r0218), 0x01));
+
+ body.emit(assign(r0353, body.constant(false), 0x01));
+
+ body.emit(assign(r0354, body.constant(true), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0552->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0559 = less(r0216, r0218);
+ ir_if *f0558 = new(mem_ctx) ir_if(operand(r0559).val);
+ exec_list *const f0558_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0558->then_instructions;
+
+ ir_expression *const r055A = sub(r0217, r0215);
+ ir_expression *const r055B = less(r0218, r0216);
+ ir_expression *const r055C = expr(ir_unop_b2i, r055B);
+ ir_expression *const r055D = expr(ir_unop_i2u, r055C);
+ body.emit(assign(r0212, sub(r055A, r055D), 0x01));
+
+ body.emit(assign(r0211, sub(r0218, r0216), 0x01));
+
+ body.emit(assign(r0354, body.constant(true), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0558->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r055F = less(r0218, r0216);
+ ir_if *f055E = new(mem_ctx) ir_if(operand(r055F).val);
+ exec_list *const f055E_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f055E->then_instructions;
+
+ ir_expression *const r0560 = sub(r0215, r0217);
+ ir_expression *const r0561 = less(r0216, r0218);
+ ir_expression *const r0562 = expr(ir_unop_b2i, r0561);
+ ir_expression *const r0563 = expr(ir_unop_i2u, r0562);
+ body.emit(assign(r0212, sub(r0560, r0563), 0x01));
+
+ body.emit(assign(r0211, sub(r0216, r0218), 0x01));
+
+ body.emit(assign(r0353, body.constant(false), 0x01));
+
+ body.emit(assign(r0354, body.constant(true), 0x01));
+
+
+ body.instructions = f055E_parent_instructions;
+ body.emit(f055E);
+
+ /* END IF */
+
+
+ body.instructions = f0558_parent_instructions;
+ body.emit(f0558);
+
+ /* END IF */
+
+
+ body.instructions = f0552_parent_instructions;
+ body.emit(f0552);
+
+ /* END IF */
+
+
+ body.instructions = f054C_parent_instructions;
+ body.emit(f054C);
+
+ /* END IF */
+
+ body.emit(assign(r0355, expr(ir_triop_csel, r0353, r0214, r0213), 0x01));
+
+ ir_expression *const r0564 = bit_xor(r0219, body.constant(1u));
+ body.emit(assign(r0219, expr(ir_triop_csel, r0353, r0219, r0564), 0x01));
+
+ ir_variable *const r0565 = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r0565, add(r0355, body.constant(int(-11))), 0x01));
+
+ ir_variable *const r0566 = body.make_temp(glsl_type::uint_type, "zFrac0");
+ ir_variable *const r0567 = body.make_temp(glsl_type::uint_type, "zFrac1");
+ ir_variable *const r0568 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac2", ir_var_auto);
+ body.emit(r0568);
+ ir_variable *const r0569 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r0569);
+ ir_expression *const r056A = equal(r0212, body.constant(0u));
+ ir_expression *const r056B = add(r0565, body.constant(int(-32)));
+ body.emit(assign(r0565, expr(ir_triop_csel, r056A, r056B, r0565), 0x01));
+
+ ir_variable *const r056C = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r056D = equal(r0212, body.constant(0u));
+ body.emit(assign(r056C, expr(ir_triop_csel, r056D, body.constant(0u), r0211), 0x01));
+
+ body.emit(assign(r0567, r056C, 0x01));
+
+ ir_variable *const r056E = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r056F = equal(r0212, body.constant(0u));
+ body.emit(assign(r056E, expr(ir_triop_csel, r056F, r056C, r0212), 0x01));
+
+ body.emit(assign(r0566, r056E, 0x01));
+
+ ir_expression *const r0570 = equal(r056E, body.constant(0u));
+ ir_expression *const r0571 = expr(ir_unop_find_msb, r056E);
+ ir_expression *const r0572 = sub(body.constant(int(31)), r0571);
+ ir_expression *const r0573 = expr(ir_triop_csel, r0570, body.constant(int(32)), r0572);
+ body.emit(assign(r0569, add(r0573, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0575 = gequal(r0569, body.constant(int(0)));
+ ir_if *f0574 = new(mem_ctx) ir_if(operand(r0575).val);
+ exec_list *const f0574_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0574->then_instructions;
+
+ body.emit(assign(r0568, body.constant(0u), 0x01));
+
+ ir_expression *const r0576 = equal(r0569, body.constant(int(0)));
+ ir_expression *const r0577 = lshift(r056E, r0569);
+ ir_expression *const r0578 = neg(r0569);
+ ir_expression *const r0579 = bit_and(r0578, body.constant(int(31)));
+ ir_expression *const r057A = rshift(r056C, r0579);
+ ir_expression *const r057B = bit_or(r0577, r057A);
+ body.emit(assign(r0566, expr(ir_triop_csel, r0576, r056E, r057B), 0x01));
+
+ body.emit(assign(r0567, lshift(r056C, r0569), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0574->else_instructions;
+
+ ir_variable *const r057C = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r057C, neg(r0569), 0x01));
+
+ ir_variable *const r057D = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ ir_variable *const r057E = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r057E);
+ ir_variable *const r057F = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r0580 = neg(r057C);
+ body.emit(assign(r057F, bit_and(r0580, body.constant(int(31))), 0x01));
+
+ ir_variable *const r0581 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0582 = less(r057C, body.constant(int(32)));
+ ir_expression *const r0583 = bit_or(body.constant(0u), r0567);
+ body.emit(assign(r0581, expr(ir_triop_csel, r0582, body.constant(0u), r0583), 0x01));
+
+ ir_expression *const r0584 = less(r057C, body.constant(int(32)));
+ ir_expression *const r0585 = lshift(r0567, r057F);
+ ir_expression *const r0586 = less(r057C, body.constant(int(64)));
+ ir_expression *const r0587 = lshift(r0566, r057F);
+ ir_expression *const r0588 = equal(r057C, body.constant(int(64)));
+ ir_expression *const r0589 = nequal(r0566, body.constant(0u));
+ ir_expression *const r058A = expr(ir_unop_b2i, r0589);
+ ir_expression *const r058B = expr(ir_unop_i2u, r058A);
+ ir_expression *const r058C = expr(ir_triop_csel, r0588, r0566, r058B);
+ ir_expression *const r058D = expr(ir_triop_csel, r0586, r0587, r058C);
+ ir_expression *const r058E = expr(ir_triop_csel, r0584, r0585, r058D);
+ ir_expression *const r058F = nequal(r0581, body.constant(0u));
+ ir_expression *const r0590 = expr(ir_unop_b2i, r058F);
+ ir_expression *const r0591 = expr(ir_unop_i2u, r0590);
+ body.emit(assign(r057E, bit_or(r058E, r0591), 0x01));
+
+ ir_variable *const r0592 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r0593 = equal(r057C, body.constant(int(0)));
+ ir_expression *const r0594 = equal(r057C, body.constant(int(32)));
+ ir_expression *const r0595 = expr(ir_triop_csel, r0594, r0567, r057E);
+ body.emit(assign(r0592, expr(ir_triop_csel, r0593, r0581, r0595), 0x01));
+
+ body.emit(assign(r057E, r0592, 0x01));
+
+ ir_expression *const r0596 = equal(r057C, body.constant(int(0)));
+ ir_expression *const r0597 = equal(r057C, body.constant(int(32)));
+ ir_expression *const r0598 = less(r057C, body.constant(int(32)));
+ ir_expression *const r0599 = lshift(r0566, r057F);
+ ir_expression *const r059A = rshift(r0567, r057C);
+ ir_expression *const r059B = bit_or(r0599, r059A);
+ ir_expression *const r059C = less(r057C, body.constant(int(64)));
+ ir_expression *const r059D = bit_and(r057C, body.constant(int(31)));
+ ir_expression *const r059E = rshift(r0566, r059D);
+ ir_expression *const r059F = expr(ir_triop_csel, r059C, r059E, body.constant(0u));
+ ir_expression *const r05A0 = expr(ir_triop_csel, r0598, r059B, r059F);
+ ir_expression *const r05A1 = expr(ir_triop_csel, r0597, r0566, r05A0);
+ body.emit(assign(r057D, expr(ir_triop_csel, r0596, r0567, r05A1), 0x01));
+
+ ir_expression *const r05A2 = equal(r057C, body.constant(int(0)));
+ ir_expression *const r05A3 = equal(r057C, body.constant(int(32)));
+ ir_expression *const r05A4 = less(r057C, body.constant(int(32)));
+ ir_expression *const r05A5 = rshift(r0566, r057C);
+ ir_expression *const r05A6 = expr(ir_triop_csel, r05A4, r05A5, body.constant(0u));
+ ir_expression *const r05A7 = expr(ir_triop_csel, r05A3, body.constant(0u), r05A6);
+ body.emit(assign(r0566, expr(ir_triop_csel, r05A2, r0566, r05A7), 0x01));
+
+ body.emit(assign(r0567, r057D, 0x01));
+
+ body.emit(assign(r0568, r0592, 0x01));
+
+
+ body.instructions = f0574_parent_instructions;
+ body.emit(f0574);
+
+ /* END IF */
+
+ body.emit(assign(r0565, sub(r0565, r0569), 0x01));
+
+ ir_variable *const r05A8 = body.make_temp(glsl_type::int_type, "zExp");
+ body.emit(assign(r05A8, r0565, 0x01));
+
+ ir_variable *const r05A9 = body.make_temp(glsl_type::uint_type, "zFrac0");
+ body.emit(assign(r05A9, r0566, 0x01));
+
+ ir_variable *const r05AA = body.make_temp(glsl_type::uint_type, "zFrac1");
+ body.emit(assign(r05AA, r0567, 0x01));
+
+ ir_variable *const r05AB = body.make_temp(glsl_type::uint_type, "zFrac2");
+ body.emit(assign(r05AB, r0568, 0x01));
+
+ ir_variable *const r05AC = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r05AC, body.constant(true), 0x01));
+
+ ir_variable *const r05AD = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r05AE = new(mem_ctx) ir_variable(glsl_type::bool_type, "increment", ir_var_auto);
+ body.emit(r05AE);
+ ir_expression *const r05AF = expr(ir_unop_u2i, r0568);
+ body.emit(assign(r05AE, less(r05AF, body.constant(int(0))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r05B1 = gequal(r0565, body.constant(int(2045)));
+ ir_if *f05B0 = new(mem_ctx) ir_if(operand(r05B1).val);
+ exec_list *const f05B0_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f05B0->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r05B3 = less(body.constant(int(2045)), r0565);
+ ir_expression *const r05B4 = equal(r0565, body.constant(int(2045)));
+ ir_expression *const r05B5 = equal(body.constant(2097151u), r0566);
+ ir_expression *const r05B6 = equal(body.constant(4294967295u), r0567);
+ ir_expression *const r05B7 = logic_and(r05B5, r05B6);
+ ir_expression *const r05B8 = logic_and(r05B4, r05B7);
+ ir_expression *const r05B9 = logic_and(r05B8, r05AE);
+ ir_expression *const r05BA = logic_or(r05B3, r05B9);
+ ir_if *f05B2 = new(mem_ctx) ir_if(operand(r05BA).val);
+ exec_list *const f05B2_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f05B2->then_instructions;
+
+ ir_variable *const r05BB = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r05BB);
+ ir_expression *const r05BC = lshift(r0219, body.constant(int(31)));
+ body.emit(assign(r05BB, add(r05BC, body.constant(2146435072u)), 0x02));
+
+ body.emit(assign(r05BB, body.constant(0u), 0x01));
+
+ body.emit(assign(r05AD, r05BB, 0x03));
+
+ body.emit(assign(r05AC, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f05B2->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r05BE = less(r0565, body.constant(int(0)));
+ ir_if *f05BD = new(mem_ctx) ir_if(operand(r05BE).val);
+ exec_list *const f05BD_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f05BD->then_instructions;
+
+ ir_variable *const r05BF = body.make_temp(glsl_type::int_type, "count");
+ body.emit(assign(r05BF, neg(r0565), 0x01));
+
+ ir_variable *const r05C0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r05C0);
+ ir_variable *const r05C1 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r05C2 = neg(r05BF);
+ body.emit(assign(r05C1, bit_and(r05C2, body.constant(int(31))), 0x01));
+
+ ir_variable *const r05C3 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r05C4 = less(r05BF, body.constant(int(32)));
+ ir_expression *const r05C5 = bit_or(r0568, r0567);
+ body.emit(assign(r05C3, expr(ir_triop_csel, r05C4, r0568, r05C5), 0x01));
+
+ ir_expression *const r05C6 = less(r05BF, body.constant(int(32)));
+ ir_expression *const r05C7 = lshift(r0567, r05C1);
+ ir_expression *const r05C8 = less(r05BF, body.constant(int(64)));
+ ir_expression *const r05C9 = lshift(r0566, r05C1);
+ ir_expression *const r05CA = equal(r05BF, body.constant(int(64)));
+ ir_expression *const r05CB = nequal(r0566, body.constant(0u));
+ ir_expression *const r05CC = expr(ir_unop_b2i, r05CB);
+ ir_expression *const r05CD = expr(ir_unop_i2u, r05CC);
+ ir_expression *const r05CE = expr(ir_triop_csel, r05CA, r0566, r05CD);
+ ir_expression *const r05CF = expr(ir_triop_csel, r05C8, r05C9, r05CE);
+ ir_expression *const r05D0 = expr(ir_triop_csel, r05C6, r05C7, r05CF);
+ ir_expression *const r05D1 = nequal(r05C3, body.constant(0u));
+ ir_expression *const r05D2 = expr(ir_unop_b2i, r05D1);
+ ir_expression *const r05D3 = expr(ir_unop_i2u, r05D2);
+ body.emit(assign(r05C0, bit_or(r05D0, r05D3), 0x01));
+
+ ir_variable *const r05D4 = body.make_temp(glsl_type::uint_type, "mix_retval");
+ ir_expression *const r05D5 = equal(r05BF, body.constant(int(0)));
+ ir_expression *const r05D6 = equal(r05BF, body.constant(int(32)));
+ ir_expression *const r05D7 = expr(ir_triop_csel, r05D6, r0567, r05C0);
+ body.emit(assign(r05D4, expr(ir_triop_csel, r05D5, r05C3, r05D7), 0x01));
+
+ body.emit(assign(r05C0, r05D4, 0x01));
+
+ ir_expression *const r05D8 = equal(r05BF, body.constant(int(0)));
+ ir_expression *const r05D9 = equal(r05BF, body.constant(int(32)));
+ ir_expression *const r05DA = less(r05BF, body.constant(int(32)));
+ ir_expression *const r05DB = rshift(r0566, r05BF);
+ ir_expression *const r05DC = expr(ir_triop_csel, r05DA, r05DB, body.constant(0u));
+ ir_expression *const r05DD = expr(ir_triop_csel, r05D9, body.constant(0u), r05DC);
+ body.emit(assign(r05A9, expr(ir_triop_csel, r05D8, r0566, r05DD), 0x01));
+
+ ir_expression *const r05DE = equal(r05BF, body.constant(int(0)));
+ ir_expression *const r05DF = equal(r05BF, body.constant(int(32)));
+ ir_expression *const r05E0 = less(r05BF, body.constant(int(32)));
+ ir_expression *const r05E1 = lshift(r0566, r05C1);
+ ir_expression *const r05E2 = rshift(r0567, r05BF);
+ ir_expression *const r05E3 = bit_or(r05E1, r05E2);
+ ir_expression *const r05E4 = less(r05BF, body.constant(int(64)));
+ ir_expression *const r05E5 = bit_and(r05BF, body.constant(int(31)));
+ ir_expression *const r05E6 = rshift(r0566, r05E5);
+ ir_expression *const r05E7 = expr(ir_triop_csel, r05E4, r05E6, body.constant(0u));
+ ir_expression *const r05E8 = expr(ir_triop_csel, r05E0, r05E3, r05E7);
+ ir_expression *const r05E9 = expr(ir_triop_csel, r05DF, r0566, r05E8);
+ body.emit(assign(r05AA, expr(ir_triop_csel, r05DE, r0567, r05E9), 0x01));
+
+ body.emit(assign(r05AB, r05D4, 0x01));
+
+ body.emit(assign(r05A8, body.constant(int(0)), 0x01));
+
+ body.emit(assign(r05AE, less(r05D4, body.constant(0u)), 0x01));
+
+
+ body.instructions = f05BD_parent_instructions;
+ body.emit(f05BD);
+
+ /* END IF */
+
+
+ body.instructions = f05B2_parent_instructions;
+ body.emit(f05B2);
+
+ /* END IF */
+
+
+ body.instructions = f05B0_parent_instructions;
+ body.emit(f05B0);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f05EA = new(mem_ctx) ir_if(operand(r05AC).val);
+ exec_list *const f05EA_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f05EA->then_instructions;
+
+ /* IF CONDITION */
+ ir_if *f05EB = new(mem_ctx) ir_if(operand(r05AE).val);
+ exec_list *const f05EB_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f05EB->then_instructions;
+
+ ir_variable *const r05EC = body.make_temp(glsl_type::uint_type, "assignment_tmp");
+ body.emit(assign(r05EC, add(r05AA, body.constant(1u)), 0x01));
+
+ ir_expression *const r05ED = less(r05EC, r05AA);
+ ir_expression *const r05EE = expr(ir_unop_b2i, r05ED);
+ ir_expression *const r05EF = expr(ir_unop_i2u, r05EE);
+ body.emit(assign(r05A9, add(r05A9, r05EF), 0x01));
+
+ ir_expression *const r05F0 = equal(r05AB, body.constant(0u));
+ ir_expression *const r05F1 = expr(ir_unop_b2i, r05F0);
+ ir_expression *const r05F2 = expr(ir_unop_i2u, r05F1);
+ ir_expression *const r05F3 = add(r05AB, r05F2);
+ ir_expression *const r05F4 = bit_and(r05F3, body.constant(1u));
+ ir_expression *const r05F5 = expr(ir_unop_bit_not, r05F4);
+ body.emit(assign(r05AA, bit_and(r05EC, r05F5), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f05EB->else_instructions;
+
+ ir_expression *const r05F6 = bit_or(r05A9, r05AA);
+ ir_expression *const r05F7 = equal(r05F6, body.constant(0u));
+ body.emit(assign(r05A8, expr(ir_triop_csel, r05F7, body.constant(int(0)), r05A8), 0x01));
+
+
+ body.instructions = f05EB_parent_instructions;
+ body.emit(f05EB);
+
+ /* END IF */
+
+ ir_variable *const r05F8 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r05F8);
+ ir_expression *const r05F9 = lshift(r0219, body.constant(int(31)));
+ ir_expression *const r05FA = expr(ir_unop_i2u, r05A8);
+ ir_expression *const r05FB = lshift(r05FA, body.constant(int(20)));
+ ir_expression *const r05FC = add(r05F9, r05FB);
+ body.emit(assign(r05F8, add(r05FC, r05A9), 0x02));
+
+ body.emit(assign(r05F8, r05AA, 0x01));
+
+ body.emit(assign(r05AD, r05F8, 0x03));
+
+ body.emit(assign(r05AC, body.constant(false), 0x01));
+
+
+ body.instructions = f05EA_parent_instructions;
+ body.emit(f05EA);
+
+ /* END IF */
+
+ ir_swizzle *const r05FD = swizzle(r0354, MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X), 2);
+ body.emit(assign(r020F, expr(ir_triop_csel, r05FD, r05AD, ir_constant::zero(mem_ctx, glsl_type::uvec2_type)), 0x03));
+
+ body.emit(assign(r020E, body.constant(false), 0x01));
+
+
+ body.instructions = f052E_parent_instructions;
+ body.emit(f052E);
+
+ /* END IF */
+
+
+ body.instructions = f0444_parent_instructions;
+ body.emit(f0444);
+
+ /* END IF */
+
+
+ body.instructions = f035E_parent_instructions;
+ body.emit(f035E);
+
+ /* END IF */
+
+
+ body.instructions = f0225_parent_instructions;
+ body.emit(f0225);
+
+ /* END IF */
+
+ body.emit(ret(r020F));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
diff --git a/src/compiler/glsl/builtin_functions.cpp b/src/compiler/glsl/builtin_functions.cpp
index e9e1e13..941f7ab 100644
--- a/src/compiler/glsl/builtin_functions.cpp
+++ b/src/compiler/glsl/builtin_functions.cpp
@@ -3362,6 +3362,10 @@ builtin_builder::create_builtins()
generate_ir::flt64(mem_ctx, integer_functions_supported),
NULL);
+ add_function("__builtin_fadd64",
+ generate_ir::fadd64(mem_ctx, integer_functions_supported),
+ NULL);
+
#undef F
#undef FI
#undef FIUD_VEC
diff --git a/src/compiler/glsl/builtin_functions.h b/src/compiler/glsl/builtin_functions.h
index baadde7..0d74736 100644
--- a/src/compiler/glsl/builtin_functions.h
+++ b/src/compiler/glsl/builtin_functions.h
@@ -82,6 +82,9 @@ feq64(void *mem_ctx, builtin_available_predicate avail);
ir_function_signature *
flt64(void *mem_ctx, builtin_available_predicate avail);
+ir_function_signature *
+fadd64(void *mem_ctx, builtin_available_predicate avail);
+
}
#endif /* BULITIN_FUNCTIONS_H */
diff --git a/src/compiler/glsl/float64.glsl b/src/compiler/glsl/float64.glsl
index fc0c94f..1629e35 100644
--- a/src/compiler/glsl/float64.glsl
+++ b/src/compiler/glsl/float64.glsl
@@ -7,6 +7,7 @@
#version 130
#extension GL_ARB_shader_bit_encoding : enable
#extension GL_EXT_shader_integer_mix : enable
+#extension GL_MESA_shader_integer_functions : enable
/* Software IEEE floating-point rounding mode.
* GLSL spec section "4.7.1 Range and Precision":
@@ -153,3 +154,430 @@ flt64(uvec2 a, uvec2 b)
return mix(lt64(a.y, a.x, b.y, b.x), lt64(b.y, b.x, a.y, a.x), aSign != 0u);
}
+
+/* Adds the 64-bit value formed by concatenating `a0' and `a1' to the 64-bit
+ * value formed by concatenating `b0' and `b1'. Addition is modulo 2^64, so
+ * any carry out is lost. The result is broken into two 32-bit pieces which
+ * are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
+ */
+void
+add64(uint a0, uint a1, uint b0, uint b1,
+ inout uint z0Ptr,
+ inout uint z1Ptr)
+{
+ uint z1 = a1 + b1;
+ z1Ptr = z1;
+ z0Ptr = a0 + b0 + uint(z1 < a1);
+}
+
+
+/* Subtracts the 64-bit value formed by concatenating `b0' and `b1' from the
+ * 64-bit value formed by concatenating `a0' and `a1'. Subtraction is modulo
+ * 2^64, so any borrow out (carry out) is lost. The result is broken into two
+ * 32-bit pieces which are stored at the locations pointed to by `z0Ptr' and
+ * `z1Ptr'.
+ */
+void
+sub64(uint a0, uint a1, uint b0, uint b1,
+ inout uint z0Ptr,
+ inout uint z1Ptr)
+{
+ z1Ptr = a1 - b1;
+ z0Ptr = a0 - b0 - uint(a1 < b1);
+}
+
+/* Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
+ * number of bits given in `count'. If any nonzero bits are shifted off, they
+ * are "jammed" into the least significant bit of the result by setting the
+ * least significant bit to 1. The value of `count' can be arbitrarily large;
+ * in particular, if `count' is greater than 64, the result will be either 0
+ * or 1, depending on whether the concatenation of `a0' and `a1' is zero or
+ * nonzero. The result is broken into two 32-bit pieces which are stored at
+ * the locations pointed to by `z0Ptr' and `z1Ptr'.
+ */
+void
+shift64RightJamming(uint a0,
+ uint a1,
+ int count,
+ inout uint z0Ptr,
+ inout uint z1Ptr)
+{
+ uint z0;
+ uint z1;
+ int negCount = (-count) & 31;
+
+ z0 = mix(0u, a0, count == 0);
+ z0 = mix(z0, (a0 >> count), count < 32);
+
+ z1 = uint((a0 | a1) != 0u); /* count >= 64 */
+ uint z1_lt64 = (a0>>(count & 31)) | uint(((a0<<negCount) | a1) != 0u);
+ z1 = mix(z1, z1_lt64, count < 64);
+ z1 = mix(z1, (a0 | uint(a1 != 0u)), count == 32);
+ uint z1_lt32 = (a0<<negCount) | (a1>>count) | uint ((a1<<negCount) != 0u);
+ z1 = mix(z1, z1_lt32, count < 32);
+ z1 = mix(z1, a1, count == 0);
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Shifts the 96-bit value formed by concatenating `a0', `a1', and `a2' right
+ * by 32 _plus_ the number of bits given in `count'. The shifted result is
+ * at most 64 nonzero bits; these are broken into two 32-bit pieces which are
+ * stored at the locations pointed to by `z0Ptr' and `z1Ptr'. The bits shifted
+ * off form a third 32-bit result as follows: The _last_ bit shifted off is
+ * the most-significant bit of the extra result, and the other 31 bits of the
+ * extra result are all zero if and only if _all_but_the_last_ bits shifted off
+ * were all zero. This extra result is stored in the location pointed to by
+ * `z2Ptr'. The value of `count' can be arbitrarily large.
+ * (This routine makes more sense if `a0', `a1', and `a2' are considered
+ * to form a fixed-point value with binary point between `a1' and `a2'. This
+ * fixed-point value is shifted right by the number of bits given in `count',
+ * and the integer part of the result is returned at the locations pointed to
+ * by `z0Ptr' and `z1Ptr'. The fractional part of the result may be slightly
+ * corrupted as described above, and is returned at the location pointed to by
+ * `z2Ptr'.)
+ */
+void
+shift64ExtraRightJamming(uint a0, uint a1, uint a2,
+ int count,
+ inout uint z0Ptr,
+ inout uint z1Ptr,
+ inout uint z2Ptr)
+{
+ uint z0 = 0u;
+ uint z1;
+ uint z2;
+ int negCount = (-count) & 31;
+
+ z2 = mix(uint(a0 != 0u), a0, count == 64);
+ z2 = mix(z2, a0 << negCount, count < 64);
+ z2 = mix(z2, a1 << negCount, count < 32);
+
+ z1 = mix(0u, (a0 >> (count & 31)), count < 64);
+ z1 = mix(z1, (a0<<negCount) | (a1>>count), count < 32);
+
+ a2 = mix(a2 | a1, a2, count < 32);
+ z0 = mix(z0, a0 >> count, count < 32);
+ z2 |= uint(a2 != 0u);
+
+ z0 = mix(z0, 0u, (count == 32));
+ z1 = mix(z1, a0, (count == 32));
+ z2 = mix(z2, a1, (count == 32));
+ z0 = mix(z0, a0, (count == 0));
+ z1 = mix(z1, a1, (count == 0));
+ z2 = mix(z2, a2, (count == 0));
+ z2Ptr = z2;
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Shifts the 64-bit value formed by concatenating `a0' and `a1' left by the
+ * number of bits given in `count'. Any bits shifted off are lost. The value
+ * of `count' must be less than 32. The result is broken into two 32-bit
+ * pieces which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
+ */
+void
+shortShift64Left(uint a0, uint a1,
+ int count,
+ inout uint z0Ptr, inout uint z1Ptr)
+{
+ z1Ptr = a1<<count;
+ z0Ptr = mix((a0 << count | (a1 >> ((-count) & 31))), a0, count == 0);
+}
+
+/* Packs the sign `zSign', the exponent `zExp', and the significand formed by
+ * the concatenation of `zFrac0' and `zFrac1' into a double-precision floating-
+ * point value, returning the result. After being shifted into the proper
+ * positions, the three fields `zSign', `zExp', and `zFrac0' are simply added
+ * together to form the most significant 32 bits of the result. This means
+ * that any integer portion of `zFrac0' will be added into the exponent. Since
+ * a properly normalized significand will have an integer portion equal to 1,
+ * the `zExp' input should be 1 less than the desired result exponent whenever
+ * `zFrac0' and `zFrac1' concatenated form a complete, normalized significand.
+ */
+uvec2
+packFloat64(uint zSign, int zExp, uint zFrac0, uint zFrac1)
+{
+ uvec2 z;
+
+ z.y = (zSign<<31) + (uint(zExp)<<20) + zFrac0;
+ z.x = zFrac1;
+ return z;
+}
+
+/* Takes an abstract floating-point value having sign `zSign', exponent `zExp',
+ * and extended significand formed by the concatenation of `zFrac0', `zFrac1',
+ * and `zFrac2', and returns the proper double-precision floating-point value
+ * corresponding to the abstract input. Ordinarily, the abstract value is
+ * simply rounded and packed into the double-precision format, with the inexact
+ * exception raised if the abstract input cannot be represented exactly.
+ * However, if the abstract value is too large, the overflow and inexact
+ * exceptions are raised and an infinity or maximal finite value is returned.
+ * If the abstract value is too small, the input value is rounded to a
+ * subnormal number, and the underflow and inexact exceptions are raised if the
+ * abstract input cannot be represented exactly as a subnormal double-precision
+ * floating-point number.
+ * The input significand must be normalized or smaller. If the input
+ * significand is not normalized, `zExp' must be 0; in that case, the result
+ * returned is a subnormal number, and it must not require rounding. In the
+ * usual case that the input significand is normalized, `zExp' must be 1 less
+ * than the "true" floating-point exponent. The handling of underflow and
+ * overflow follows the IEEE Standard for Floating-Point Arithmetic.
+ */
+uvec2
+roundAndPackFloat64(uint zSign,
+ int zExp,
+ uint zFrac0,
+ uint zFrac1,
+ uint zFrac2)
+{
+ bool roundNearestEven;
+ bool increment;
+
+ roundNearestEven = FLOAT_ROUNDING_MODE == FLOAT_ROUND_NEAREST_EVEN;
+ increment = int(zFrac2) < 0;
+ if (!roundNearestEven) {
+ if (FLOAT_ROUNDING_MODE == FLOAT_ROUND_TO_ZERO) {
+ increment = false;
+ } else {
+ if (zSign != 0u) {
+ increment = (FLOAT_ROUNDING_MODE == FLOAT_ROUND_DOWN) &&
+ (zFrac2 != 0u);
+ } else {
+ increment = (FLOAT_ROUNDING_MODE == FLOAT_ROUND_UP) &&
+ (zFrac2 != 0u);
+ }
+ }
+ }
+ if (0x7FD <= zExp) {
+ if ((0x7FD < zExp) ||
+ ((zExp == 0x7FD) &&
+ (0x001FFFFFu == zFrac0 && 0xFFFFFFFFu == zFrac1) &&
+ increment)) {
+ if ((FLOAT_ROUNDING_MODE == FLOAT_ROUND_TO_ZERO) ||
+ ((zSign != 0u) && (FLOAT_ROUNDING_MODE == FLOAT_ROUND_UP)) ||
+ ((zSign == 0u) && (FLOAT_ROUNDING_MODE == FLOAT_ROUND_DOWN))) {
+ return packFloat64(zSign, 0x7FE, 0x000FFFFFu, 0xFFFFFFFFu);
+ }
+ return packFloat64(zSign, 0x7FF, 0u, 0u);
+ }
+ if (zExp < 0) {
+ shift64ExtraRightJamming(
+ zFrac0, zFrac1, zFrac2, -zExp, zFrac0, zFrac1, zFrac2);
+ zExp = 0;
+ if (roundNearestEven) {
+ increment = zFrac2 < 0u;
+ } else {
+ if (zSign != 0u) {
+ increment = (FLOAT_ROUNDING_MODE == FLOAT_ROUND_DOWN) &&
+ (zFrac2 != 0u);
+ } else {
+ increment = (FLOAT_ROUNDING_MODE == FLOAT_ROUND_UP) &&
+ (zFrac2 != 0u);
+ }
+ }
+ }
+ }
+ if (increment) {
+ add64(zFrac0, zFrac1, 0u, 1u, zFrac0, zFrac1);
+ zFrac1 &= ~((zFrac2 + uint(zFrac2 == 0u)) & uint(roundNearestEven));
+ } else {
+ zExp = mix(zExp, 0, (zFrac0 | zFrac1) == 0u);
+ }
+ return packFloat64(zSign, zExp, zFrac0, zFrac1);
+}
+
+/* Returns the number of leading 0 bits before the most-significant 1 bit of
+ * `a'. If `a' is zero, 32 is returned.
+ */
+int
+countLeadingZeros32(uint a)
+{
+ int shiftCount;
+ shiftCount = mix(31 - findMSB(a), 32, a == 0u);
+ return shiftCount;
+}
+
+/* Takes an abstract floating-point value having sign `zSign', exponent `zExp',
+ * and significand formed by the concatenation of `zSig0' and `zSig1', and
+ * returns the proper double-precision floating-point value corresponding
+ * to the abstract input. This routine is just like `roundAndPackFloat64'
+ * except that the input significand has fewer bits and does not have to be
+ * normalized. In all cases, `zExp' must be 1 less than the "true" floating-
+ * point exponent.
+ */
+uvec2
+normalizeRoundAndPackFloat64(uint zSign,
+ int zExp,
+ uint zFrac0,
+ uint zFrac1)
+{
+ int shiftCount;
+ uint zFrac2;
+
+ zExp = mix(zExp, zExp - 32, zFrac0 == 0u);
+ zFrac1 = mix(zFrac1, 0u, zFrac0 == 0u);
+ zFrac0 = mix(zFrac0, zFrac1, zFrac0 == 0u);
+ shiftCount = countLeadingZeros32(zFrac0) - 11;
+ if (0 <= shiftCount) {
+ zFrac2 = 0u;
+ shortShift64Left(zFrac0, zFrac1, shiftCount, zFrac0, zFrac1);
+ } else {
+ shift64ExtraRightJamming(
+ zFrac0, zFrac1, 0u, -shiftCount, zFrac0, zFrac1, zFrac2);
+ }
+ zExp -= shiftCount;
+ return roundAndPackFloat64(zSign, zExp, zFrac0, zFrac1, zFrac2);
+}
+
+/* Takes two double-precision floating-point values `a' and `b', one of which
+ * is a NaN, and returns the appropriate NaN result.
+ */
+uvec2
+propagateFloat64NaN(uvec2 a, uvec2 b)
+{
+ bool aIsNaN = is_nan(a);
+ bool bIsNaN = is_nan(b);
+ a.y |= 0x00080000u;
+ b.y |= 0x00080000u;
+
+ return mix(b, mix(a, b, bvec2(bIsNaN, bIsNaN)), bvec2(aIsNaN, aIsNaN));
+}
+
+/* Returns the result of adding the double-precision floating-point values
+ * `a' and `b'. The operation is performed according to the IEEE Standard for
+ * Floating-Point Arithmetic.
+ */
+uvec2
+fadd64(uvec2 a, uvec2 b)
+{
+ uint aSign = extractFloat64Sign(a);
+ uint bSign = extractFloat64Sign(b);
+ uint aFracLo = extractFloat64FracLo(a);
+ uint aFracHi = extractFloat64FracHi(a);
+ uint bFracLo = extractFloat64FracLo(b);
+ uint bFracHi = extractFloat64FracHi(b);
+ int aExp = extractFloat64Exp(a);
+ int bExp = extractFloat64Exp(b);
+ uint zFrac0 = 0u;
+ uint zFrac1 = 0u;
+ int expDiff = aExp - bExp;
+ if (aSign == bSign) {
+ uint zFrac2 = 0u;
+ int zExp;
+ bool orig_exp_diff_is_zero = (expDiff == 0);
+
+ if (orig_exp_diff_is_zero) {
+ if (aExp == 0x7FF) {
+ bool propagate = (aFracHi | aFracLo | bFracHi | bFracLo) != 0u;
+ return mix(a, propagateFloat64NaN(a, b), bvec2(propagate, propagate));
+ }
+ add64(aFracHi, aFracLo, bFracHi, bFracLo, zFrac0, zFrac1);
+ if (aExp == 0)
+ return packFloat64(aSign, 0, zFrac0, zFrac1);
+ zFrac2 = 0u;
+ zFrac0 |= 0x00200000u;
+ zExp = aExp;
+ shift64ExtraRightJamming(
+ zFrac0, zFrac1, zFrac2, 1, zFrac0, zFrac1, zFrac2);
+ } else if (0 < expDiff) {
+ if (aExp == 0x7FF) {
+ bool propagate = (aFracHi | aFracLo) != 0u;
+ return mix(a, propagateFloat64NaN(a, b), bvec2(propagate, propagate));
+ }
+
+ expDiff = mix(expDiff, expDiff - 1, bExp == 0);
+ bFracHi = mix(bFracHi | 0x00100000u, bFracHi, bExp == 0);
+ shift64ExtraRightJamming(
+ bFracHi, bFracLo, 0u, expDiff, bFracHi, bFracLo, zFrac2);
+ zExp = aExp;
+ } else if (expDiff < 0) {
+ if (bExp == 0x7FF) {
+ bool propagate = (bFracHi | bFracLo) != 0u;
+ return mix(packFloat64(aSign, 0x7ff, 0u, 0u), propagateFloat64NaN(a, b), bvec2(propagate, propagate));
+ }
+ expDiff = mix(expDiff, expDiff + 1, aExp == 0);
+ aFracHi = mix(aFracHi | 0x00100000u, aFracHi, aExp == 0);
+ shift64ExtraRightJamming(
+ aFracHi, aFracLo, 0u, - expDiff, aFracHi, aFracLo, zFrac2);
+ zExp = bExp;
+ }
+ if (!orig_exp_diff_is_zero) {
+ aFracHi |= 0x00100000u;
+ add64(aFracHi, aFracLo, bFracHi, bFracLo, zFrac0, zFrac1);
+ --zExp;
+ if (!(zFrac0 < 0x00200000u)) {
+ shift64ExtraRightJamming(zFrac0, zFrac1, zFrac2, 1, zFrac0, zFrac1, zFrac2);
+ ++zExp;
+ }
+ }
+ return roundAndPackFloat64(aSign, zExp, zFrac0, zFrac1, zFrac2);
+
+ } else {
+ uvec2 z;
+ int zExp;
+
+ shortShift64Left(aFracHi, aFracLo, 10, aFracHi, aFracLo);
+ shortShift64Left(bFracHi, bFracLo, 10, bFracHi, bFracLo);
+ if (0 < expDiff) {
+ if (aExp == 0x7FF) {
+ bool propagate = (aFracHi | aFracLo) != 0u;
+ return mix(a, propagateFloat64NaN(a, b), bvec2(propagate, propagate));
+ }
+ expDiff = mix(expDiff, expDiff - 1, bExp == 0);
+ bFracHi = mix(bFracHi | 0x40000000u, bFracHi, bExp == 0);
+ shift64RightJamming(bFracHi, bFracLo, expDiff, bFracHi, bFracLo);
+ aFracHi |= 0x40000000u;
+ sub64(aFracHi, aFracLo, bFracHi, bFracLo, zFrac0, zFrac1);
+ zExp = aExp;
+ --zExp;
+ return normalizeRoundAndPackFloat64(aSign, zExp - 10, zFrac0, zFrac1);
+ }
+ if (expDiff < 0) {
+ if (bExp == 0x7FF) {
+ bool propagate = (bFracHi | bFracLo) != 0u;
+ return mix(packFloat64(aSign ^ 1u, 0x7ff, 0u, 0u), propagateFloat64NaN(a, b), bvec2(propagate, propagate));
+ }
+ expDiff = mix(expDiff, expDiff + 1, aExp == 0);
+ aFracHi = mix(aFracHi | 0x40000000u, aFracHi, aExp == 0);
+ shift64RightJamming(aFracHi, aFracLo, - expDiff, aFracHi, aFracLo);
+ bFracHi |= 0x40000000u;
+ sub64(bFracHi, bFracLo, aFracHi, aFracLo, zFrac0, zFrac1);
+ zExp = bExp;
+ aSign ^= 1u;
+ --zExp;
+ return normalizeRoundAndPackFloat64(aSign, zExp - 10, zFrac0, zFrac1);
+ }
+ if (aExp == 0x7FF) {
+ bool propagate = (aFracHi | aFracLo | bFracHi | bFracLo) != 0u;
+ return mix(uvec2(0xFFFFFFFFu, 0xFFFFFFFFu), propagateFloat64NaN(a, b), bvec2(propagate, propagate));
+ }
+ bExp = mix(bExp, 1, aExp == 0);
+ aExp = mix(aExp, 1, aExp == 0);
+ bool zexp_normal = false;
+ bool blta = true;
+ if (bFracHi < aFracHi) {
+ sub64(aFracHi, aFracLo, bFracHi, bFracLo, zFrac0, zFrac1);
+ zexp_normal = true;
+ }
+ else if (aFracHi < bFracHi) {
+ sub64(bFracHi, bFracLo, aFracHi, aFracLo, zFrac0, zFrac1);
+ blta = false;
+ zexp_normal = true;
+ }
+ else if (bFracLo < aFracLo) {
+ sub64(aFracHi, aFracLo, bFracHi, bFracLo, zFrac0, zFrac1);
+ zexp_normal = true;
+ }
+ else if (aFracLo < bFracLo) {
+ sub64(bFracHi, bFracLo, aFracHi, aFracLo, zFrac0, zFrac1);
+ blta = false;
+ zexp_normal = true;
+ }
+ zExp = mix(bExp, aExp, blta);
+ aSign = mix(aSign ^ 1u, aSign, blta);
+ uvec2 retval_0 = packFloat64(uint(FLOAT_ROUNDING_MODE == FLOAT_ROUND_DOWN), 0, 0u, 0u);
+ uvec2 retval_1 = normalizeRoundAndPackFloat64(aSign, zExp - 11, zFrac0, zFrac1);
+ return mix(retval_0, retval_1, bvec2(zexp_normal, zexp_normal));
+ }
+}
diff --git a/src/compiler/glsl/glcpp/glcpp-parse.y b/src/compiler/glsl/glcpp/glcpp-parse.y
index da21cc2..fce4b5f 100644
--- a/src/compiler/glsl/glcpp/glcpp-parse.y
+++ b/src/compiler/glsl/glcpp/glcpp-parse.y
@@ -2373,6 +2373,7 @@ _glcpp_parser_handle_version_declaration(glcpp_parser_t *parser, intmax_t versio
add_builtin_define(parser, "__have_builtin_builtin_fsign64", 1);
add_builtin_define(parser, "__have_builtin_builtin_feq64", 1);
add_builtin_define(parser, "__have_builtin_builtin_flt64", 1);
+ add_builtin_define(parser, "__have_builtin_builtin_fadd64", 1);
}
}
--
2.9.5
More information about the mesa-dev
mailing list