[Mesa-dev] [RFC 07/11] glsl: Add "built-in" functions to do mul(fp64, fp64)
Elie Tournier
tournier.elie at gmail.com
Fri Mar 3 16:23:03 UTC 2017
Signed-off-by: Elie Tournier <elie.tournier at collabora.com>
---
src/compiler/glsl/builtin_float64.h | 2558 +++++++++++++++++++++++++++++++
src/compiler/glsl/builtin_functions.cpp | 4 +
src/compiler/glsl/builtin_functions.h | 3 +
src/compiler/glsl/float64.glsl | 172 +++
4 files changed, 2737 insertions(+)
diff --git a/src/compiler/glsl/builtin_float64.h b/src/compiler/glsl/builtin_float64.h
index bf0953e5d6..0a363bd27a 100644
--- a/src/compiler/glsl/builtin_float64.h
+++ b/src/compiler/glsl/builtin_float64.h
@@ -17451,3 +17451,2561 @@ r0BC3_data.u[1] = 4294967295;
sig->replace_parameters(&sig_parameters);
return sig;
}
+ir_function_signature *
+mul32To64(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 r0E13 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a", ir_var_function_in);
+ sig_parameters.push_tail(r0E13);
+ ir_variable *const r0E14 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b", ir_var_function_in);
+ sig_parameters.push_tail(r0E14);
+ ir_variable *const r0E15 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E15);
+ ir_variable *const r0E16 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E16);
+ ir_variable *const r0E17 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E17);
+ ir_variable *const r0E18 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0E18);
+ ir_variable *const r0E19 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0E19);
+ ir_variable *const r0E1A = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0E1A);
+ ir_variable *const r0E1B = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0E1B);
+ ir_variable *const r0E1C = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0E1C);
+ body.emit(assign(r0E1C, rshift(r0E13, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E1B, rshift(r0E14, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E17, mul(r0E13, r0E14), 0x01));
+
+ body.emit(assign(r0E19, mul(r0E13, r0E1B), 0x01));
+
+ body.emit(assign(r0E18, mul(r0E1C, r0E14), 0x01));
+
+ body.emit(assign(r0E1A, mul(r0E1C, r0E1B), 0x01));
+
+ body.emit(assign(r0E19, add(r0E19, r0E18), 0x01));
+
+ ir_expression *const r0E1D = less(r0E19, r0E18);
+ ir_expression *const r0E1E = expr(ir_unop_b2i, r0E1D);
+ ir_expression *const r0E1F = expr(ir_unop_i2u, r0E1E);
+ ir_expression *const r0E20 = lshift(r0E1F, body.constant(int(16)));
+ ir_expression *const r0E21 = rshift(r0E19, body.constant(int(16)));
+ ir_expression *const r0E22 = add(r0E20, r0E21);
+ body.emit(assign(r0E1A, add(r0E1A, r0E22), 0x01));
+
+ body.emit(assign(r0E19, lshift(r0E19, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E17, add(r0E17, r0E19), 0x01));
+
+ ir_expression *const r0E23 = less(r0E17, r0E19);
+ ir_expression *const r0E24 = expr(ir_unop_b2i, r0E23);
+ ir_expression *const r0E25 = expr(ir_unop_i2u, r0E24);
+ body.emit(assign(r0E1A, add(r0E1A, r0E25), 0x01));
+
+ body.emit(assign(r0E16, r0E17, 0x01));
+
+ body.emit(assign(r0E15, r0E1A, 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+mul64To128(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 r0E26 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r0E26);
+ ir_variable *const r0E27 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r0E27);
+ ir_variable *const r0E28 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b0", ir_var_function_in);
+ sig_parameters.push_tail(r0E28);
+ ir_variable *const r0E29 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b1", ir_var_function_in);
+ sig_parameters.push_tail(r0E29);
+ ir_variable *const r0E2A = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E2A);
+ ir_variable *const r0E2B = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E2B);
+ ir_variable *const r0E2C = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E2C);
+ ir_variable *const r0E2D = new(mem_ctx) ir_variable(glsl_type::uint_type, "z3Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E2D);
+ ir_variable *const r0E2E = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E2E);
+ ir_variable *const r0E2F = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0E2F);
+ ir_variable *const r0E30 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0E30);
+ ir_variable *const r0E31 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0E31);
+ ir_variable *const r0E32 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0E32);
+ ir_variable *const r0E33 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0E33);
+ body.emit(assign(r0E33, rshift(r0E27, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E32, rshift(r0E29, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E2E, mul(r0E27, r0E29), 0x01));
+
+ body.emit(assign(r0E30, mul(r0E27, r0E32), 0x01));
+
+ body.emit(assign(r0E2F, mul(r0E33, r0E29), 0x01));
+
+ body.emit(assign(r0E31, mul(r0E33, r0E32), 0x01));
+
+ body.emit(assign(r0E30, add(r0E30, r0E2F), 0x01));
+
+ ir_expression *const r0E34 = less(r0E30, r0E2F);
+ ir_expression *const r0E35 = expr(ir_unop_b2i, r0E34);
+ ir_expression *const r0E36 = expr(ir_unop_i2u, r0E35);
+ ir_expression *const r0E37 = lshift(r0E36, body.constant(int(16)));
+ ir_expression *const r0E38 = rshift(r0E30, body.constant(int(16)));
+ ir_expression *const r0E39 = add(r0E37, r0E38);
+ body.emit(assign(r0E31, add(r0E31, r0E39), 0x01));
+
+ body.emit(assign(r0E30, lshift(r0E30, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E2E, add(r0E2E, r0E30), 0x01));
+
+ ir_expression *const r0E3A = less(r0E2E, r0E30);
+ ir_expression *const r0E3B = expr(ir_unop_b2i, r0E3A);
+ ir_expression *const r0E3C = expr(ir_unop_i2u, r0E3B);
+ body.emit(assign(r0E31, add(r0E31, r0E3C), 0x01));
+
+ ir_variable *const r0E3D = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E3D);
+ ir_variable *const r0E3E = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0E3E);
+ ir_variable *const r0E3F = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0E3F);
+ ir_variable *const r0E40 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0E40);
+ ir_variable *const r0E41 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0E41);
+ ir_variable *const r0E42 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0E42);
+ body.emit(assign(r0E42, rshift(r0E27, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E41, rshift(r0E28, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E3D, mul(r0E27, r0E28), 0x01));
+
+ body.emit(assign(r0E3F, mul(r0E27, r0E41), 0x01));
+
+ body.emit(assign(r0E3E, mul(r0E42, r0E28), 0x01));
+
+ body.emit(assign(r0E40, mul(r0E42, r0E41), 0x01));
+
+ body.emit(assign(r0E3F, add(r0E3F, r0E3E), 0x01));
+
+ ir_expression *const r0E43 = less(r0E3F, r0E3E);
+ ir_expression *const r0E44 = expr(ir_unop_b2i, r0E43);
+ ir_expression *const r0E45 = expr(ir_unop_i2u, r0E44);
+ ir_expression *const r0E46 = lshift(r0E45, body.constant(int(16)));
+ ir_expression *const r0E47 = rshift(r0E3F, body.constant(int(16)));
+ ir_expression *const r0E48 = add(r0E46, r0E47);
+ body.emit(assign(r0E40, add(r0E40, r0E48), 0x01));
+
+ body.emit(assign(r0E3F, lshift(r0E3F, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E3D, add(r0E3D, r0E3F), 0x01));
+
+ ir_expression *const r0E49 = less(r0E3D, r0E3F);
+ ir_expression *const r0E4A = expr(ir_unop_b2i, r0E49);
+ ir_expression *const r0E4B = expr(ir_unop_i2u, r0E4A);
+ body.emit(assign(r0E40, add(r0E40, r0E4B), 0x01));
+
+ ir_variable *const r0E4C = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E4C);
+ body.emit(assign(r0E4C, add(r0E3D, r0E31), 0x01));
+
+ ir_variable *const r0E4D = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E4D);
+ ir_variable *const r0E4E = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0E4E);
+ ir_variable *const r0E4F = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0E4F);
+ ir_variable *const r0E50 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0E50);
+ ir_variable *const r0E51 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0E51);
+ ir_variable *const r0E52 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0E52);
+ body.emit(assign(r0E52, rshift(r0E26, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E51, rshift(r0E28, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E4D, mul(r0E26, r0E28), 0x01));
+
+ body.emit(assign(r0E4F, mul(r0E26, r0E51), 0x01));
+
+ body.emit(assign(r0E4E, mul(r0E52, r0E28), 0x01));
+
+ body.emit(assign(r0E50, mul(r0E52, r0E51), 0x01));
+
+ body.emit(assign(r0E4F, add(r0E4F, r0E4E), 0x01));
+
+ ir_expression *const r0E53 = less(r0E4F, r0E4E);
+ ir_expression *const r0E54 = expr(ir_unop_b2i, r0E53);
+ ir_expression *const r0E55 = expr(ir_unop_i2u, r0E54);
+ ir_expression *const r0E56 = lshift(r0E55, body.constant(int(16)));
+ ir_expression *const r0E57 = rshift(r0E4F, body.constant(int(16)));
+ ir_expression *const r0E58 = add(r0E56, r0E57);
+ body.emit(assign(r0E50, add(r0E50, r0E58), 0x01));
+
+ body.emit(assign(r0E4F, lshift(r0E4F, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E4D, add(r0E4D, r0E4F), 0x01));
+
+ ir_expression *const r0E59 = less(r0E4D, r0E4F);
+ ir_expression *const r0E5A = expr(ir_unop_b2i, r0E59);
+ ir_expression *const r0E5B = expr(ir_unop_i2u, r0E5A);
+ body.emit(assign(r0E50, add(r0E50, r0E5B), 0x01));
+
+ ir_variable *const r0E5C = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E5C);
+ ir_expression *const r0E5D = less(r0E4C, r0E3D);
+ ir_expression *const r0E5E = expr(ir_unop_b2i, r0E5D);
+ ir_expression *const r0E5F = expr(ir_unop_i2u, r0E5E);
+ ir_expression *const r0E60 = add(r0E40, r0E5F);
+ body.emit(assign(r0E5C, add(r0E4D, r0E60), 0x01));
+
+ ir_variable *const r0E61 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E61);
+ ir_variable *const r0E62 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0E62);
+ ir_variable *const r0E63 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0E63);
+ ir_variable *const r0E64 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0E64);
+ ir_variable *const r0E65 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0E65);
+ ir_variable *const r0E66 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0E66);
+ body.emit(assign(r0E66, rshift(r0E26, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E65, rshift(r0E29, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E61, mul(r0E26, r0E29), 0x01));
+
+ body.emit(assign(r0E63, mul(r0E26, r0E65), 0x01));
+
+ body.emit(assign(r0E62, mul(r0E66, r0E29), 0x01));
+
+ body.emit(assign(r0E64, mul(r0E66, r0E65), 0x01));
+
+ body.emit(assign(r0E63, add(r0E63, r0E62), 0x01));
+
+ ir_expression *const r0E67 = less(r0E63, r0E62);
+ ir_expression *const r0E68 = expr(ir_unop_b2i, r0E67);
+ ir_expression *const r0E69 = expr(ir_unop_i2u, r0E68);
+ ir_expression *const r0E6A = lshift(r0E69, body.constant(int(16)));
+ ir_expression *const r0E6B = rshift(r0E63, body.constant(int(16)));
+ ir_expression *const r0E6C = add(r0E6A, r0E6B);
+ body.emit(assign(r0E64, add(r0E64, r0E6C), 0x01));
+
+ body.emit(assign(r0E63, lshift(r0E63, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0E61, add(r0E61, r0E63), 0x01));
+
+ ir_expression *const r0E6D = less(r0E61, r0E63);
+ ir_expression *const r0E6E = expr(ir_unop_b2i, r0E6D);
+ ir_expression *const r0E6F = expr(ir_unop_i2u, r0E6E);
+ body.emit(assign(r0E64, add(r0E64, r0E6F), 0x01));
+
+ ir_variable *const r0E70 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E70);
+ body.emit(assign(r0E70, add(r0E61, r0E4C), 0x01));
+
+ ir_variable *const r0E71 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0E71);
+ ir_expression *const r0E72 = less(r0E70, r0E61);
+ ir_expression *const r0E73 = expr(ir_unop_b2i, r0E72);
+ ir_expression *const r0E74 = expr(ir_unop_i2u, r0E73);
+ ir_expression *const r0E75 = add(r0E64, r0E74);
+ body.emit(assign(r0E71, add(r0E5C, r0E75), 0x01));
+
+ body.emit(assign(r0E2D, r0E2E, 0x01));
+
+ body.emit(assign(r0E2C, r0E70, 0x01));
+
+ body.emit(assign(r0E2B, r0E71, 0x01));
+
+ ir_expression *const r0E76 = less(r0E5C, r0E4D);
+ ir_expression *const r0E77 = expr(ir_unop_b2i, r0E76);
+ ir_expression *const r0E78 = expr(ir_unop_i2u, r0E77);
+ ir_expression *const r0E79 = add(r0E50, r0E78);
+ ir_expression *const r0E7A = less(r0E71, r0E5C);
+ ir_expression *const r0E7B = expr(ir_unop_b2i, r0E7A);
+ ir_expression *const r0E7C = expr(ir_unop_i2u, r0E7B);
+ body.emit(assign(r0E2A, add(r0E79, r0E7C), 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+normalizeFloat64Subnormal(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 r0E7D = new(mem_ctx) ir_variable(glsl_type::uint_type, "aFrac0", ir_var_function_in);
+ sig_parameters.push_tail(r0E7D);
+ ir_variable *const r0E7E = new(mem_ctx) ir_variable(glsl_type::uint_type, "aFrac1", ir_var_function_in);
+ sig_parameters.push_tail(r0E7E);
+ ir_variable *const r0E7F = new(mem_ctx) ir_variable(glsl_type::uint_type, "zExpPtr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E7F);
+ ir_variable *const r0E80 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E80);
+ ir_variable *const r0E81 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r0E81);
+ ir_variable *const r0E82 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r0E82);
+ /* IF CONDITION */
+ ir_expression *const r0E84 = equal(r0E7D, body.constant(0u));
+ ir_if *f0E83 = new(mem_ctx) ir_if(operand(r0E84).val);
+ exec_list *const f0E83_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0E83->then_instructions;
+
+ ir_variable *const r0E85 = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r0E85, r0E7E, 0x01));
+
+ ir_variable *const r0E86 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r0E87 = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r0E87);
+ /* IF CONDITION */
+ ir_expression *const r0E89 = equal(r0E7E, body.constant(0u));
+ ir_if *f0E88 = new(mem_ctx) ir_if(operand(r0E89).val);
+ exec_list *const f0E88_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0E88->then_instructions;
+
+ body.emit(assign(r0E86, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0E88->else_instructions;
+
+ body.emit(assign(r0E87, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0E8B = bit_and(r0E7E, body.constant(4294901760u));
+ ir_expression *const r0E8C = equal(r0E8B, body.constant(0u));
+ ir_if *f0E8A = new(mem_ctx) ir_if(operand(r0E8C).val);
+ exec_list *const f0E8A_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0E8A->then_instructions;
+
+ body.emit(assign(r0E87, body.constant(16u), 0x01));
+
+ body.emit(assign(r0E85, lshift(r0E7E, body.constant(int(16))), 0x01));
+
+
+ body.instructions = f0E8A_parent_instructions;
+ body.emit(f0E8A);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0E8E = bit_and(r0E85, body.constant(4278190080u));
+ ir_expression *const r0E8F = equal(r0E8E, body.constant(0u));
+ ir_if *f0E8D = new(mem_ctx) ir_if(operand(r0E8F).val);
+ exec_list *const f0E8D_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0E8D->then_instructions;
+
+ body.emit(assign(r0E87, add(r0E87, body.constant(8u)), 0x01));
+
+ body.emit(assign(r0E85, lshift(r0E85, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f0E8D_parent_instructions;
+ body.emit(f0E8D);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0E91 = bit_and(r0E85, body.constant(4026531840u));
+ ir_expression *const r0E92 = equal(r0E91, body.constant(0u));
+ ir_if *f0E90 = new(mem_ctx) ir_if(operand(r0E92).val);
+ exec_list *const f0E90_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0E90->then_instructions;
+
+ body.emit(assign(r0E87, add(r0E87, body.constant(4u)), 0x01));
+
+ body.emit(assign(r0E85, lshift(r0E85, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f0E90_parent_instructions;
+ body.emit(f0E90);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0E94 = bit_and(r0E85, body.constant(3221225472u));
+ ir_expression *const r0E95 = equal(r0E94, body.constant(0u));
+ ir_if *f0E93 = new(mem_ctx) ir_if(operand(r0E95).val);
+ exec_list *const f0E93_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0E93->then_instructions;
+
+ body.emit(assign(r0E87, add(r0E87, body.constant(2u)), 0x01));
+
+ body.emit(assign(r0E85, lshift(r0E85, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f0E93_parent_instructions;
+ body.emit(f0E93);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0E97 = bit_and(r0E85, body.constant(2147483648u));
+ ir_expression *const r0E98 = equal(r0E97, body.constant(0u));
+ ir_if *f0E96 = new(mem_ctx) ir_if(operand(r0E98).val);
+ exec_list *const f0E96_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0E96->then_instructions;
+
+ body.emit(assign(r0E87, add(r0E87, body.constant(1u)), 0x01));
+
+
+ body.instructions = f0E96_parent_instructions;
+ body.emit(f0E96);
+
+ /* END IF */
+
+ body.emit(assign(r0E86, r0E87, 0x01));
+
+
+ body.instructions = f0E88_parent_instructions;
+ body.emit(f0E88);
+
+ /* END IF */
+
+ ir_expression *const r0E99 = expr(ir_unop_u2i, r0E86);
+ body.emit(assign(r0E82, add(r0E99, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0E9B = less(r0E82, body.constant(int(0)));
+ ir_if *f0E9A = new(mem_ctx) ir_if(operand(r0E9B).val);
+ exec_list *const f0E9A_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0E9A->then_instructions;
+
+ ir_expression *const r0E9C = neg(r0E82);
+ body.emit(assign(r0E80, rshift(r0E7E, r0E9C), 0x01));
+
+ ir_expression *const r0E9D = bit_and(r0E82, body.constant(int(31)));
+ body.emit(assign(r0E81, lshift(r0E7E, r0E9D), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0E9A->else_instructions;
+
+ body.emit(assign(r0E80, lshift(r0E7E, r0E82), 0x01));
+
+ body.emit(assign(r0E81, body.constant(0u), 0x01));
+
+
+ body.instructions = f0E9A_parent_instructions;
+ body.emit(f0E9A);
+
+ /* END IF */
+
+ ir_expression *const r0E9E = sub(body.constant(int(-31)), r0E82);
+ body.emit(assign(r0E7F, expr(ir_unop_i2u, r0E9E), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0E83->else_instructions;
+
+ ir_variable *const r0E9F = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r0E9F, r0E7D, 0x01));
+
+ ir_variable *const r0EA0 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r0EA1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r0EA1);
+ /* IF CONDITION */
+ ir_expression *const r0EA3 = equal(r0E7D, body.constant(0u));
+ ir_if *f0EA2 = new(mem_ctx) ir_if(operand(r0EA3).val);
+ exec_list *const f0EA2_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EA2->then_instructions;
+
+ body.emit(assign(r0EA0, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0EA2->else_instructions;
+
+ body.emit(assign(r0EA1, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0EA5 = bit_and(r0E7D, body.constant(4294901760u));
+ ir_expression *const r0EA6 = equal(r0EA5, body.constant(0u));
+ ir_if *f0EA4 = new(mem_ctx) ir_if(operand(r0EA6).val);
+ exec_list *const f0EA4_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EA4->then_instructions;
+
+ body.emit(assign(r0EA1, body.constant(16u), 0x01));
+
+ body.emit(assign(r0E9F, lshift(r0E7D, body.constant(int(16))), 0x01));
+
+
+ body.instructions = f0EA4_parent_instructions;
+ body.emit(f0EA4);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0EA8 = bit_and(r0E9F, body.constant(4278190080u));
+ ir_expression *const r0EA9 = equal(r0EA8, body.constant(0u));
+ ir_if *f0EA7 = new(mem_ctx) ir_if(operand(r0EA9).val);
+ exec_list *const f0EA7_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EA7->then_instructions;
+
+ body.emit(assign(r0EA1, add(r0EA1, body.constant(8u)), 0x01));
+
+ body.emit(assign(r0E9F, lshift(r0E9F, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f0EA7_parent_instructions;
+ body.emit(f0EA7);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0EAB = bit_and(r0E9F, body.constant(4026531840u));
+ ir_expression *const r0EAC = equal(r0EAB, body.constant(0u));
+ ir_if *f0EAA = new(mem_ctx) ir_if(operand(r0EAC).val);
+ exec_list *const f0EAA_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EAA->then_instructions;
+
+ body.emit(assign(r0EA1, add(r0EA1, body.constant(4u)), 0x01));
+
+ body.emit(assign(r0E9F, lshift(r0E9F, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f0EAA_parent_instructions;
+ body.emit(f0EAA);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0EAE = bit_and(r0E9F, body.constant(3221225472u));
+ ir_expression *const r0EAF = equal(r0EAE, body.constant(0u));
+ ir_if *f0EAD = new(mem_ctx) ir_if(operand(r0EAF).val);
+ exec_list *const f0EAD_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EAD->then_instructions;
+
+ body.emit(assign(r0EA1, add(r0EA1, body.constant(2u)), 0x01));
+
+ body.emit(assign(r0E9F, lshift(r0E9F, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f0EAD_parent_instructions;
+ body.emit(f0EAD);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0EB1 = bit_and(r0E9F, body.constant(2147483648u));
+ ir_expression *const r0EB2 = equal(r0EB1, body.constant(0u));
+ ir_if *f0EB0 = new(mem_ctx) ir_if(operand(r0EB2).val);
+ exec_list *const f0EB0_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EB0->then_instructions;
+
+ body.emit(assign(r0EA1, add(r0EA1, body.constant(1u)), 0x01));
+
+
+ body.instructions = f0EB0_parent_instructions;
+ body.emit(f0EB0);
+
+ /* END IF */
+
+ body.emit(assign(r0EA0, r0EA1, 0x01));
+
+
+ body.instructions = f0EA2_parent_instructions;
+ body.emit(f0EA2);
+
+ /* END IF */
+
+ ir_expression *const r0EB3 = expr(ir_unop_u2i, r0EA0);
+ body.emit(assign(r0E82, add(r0EB3, body.constant(int(-11))), 0x01));
+
+ ir_variable *const r0EB4 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r0EB4, lshift(r0E7E, r0E82), 0x01));
+
+ ir_variable *const r0EB5 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r0EB7 = equal(r0E82, body.constant(int(0)));
+ ir_if *f0EB6 = new(mem_ctx) ir_if(operand(r0EB7).val);
+ exec_list *const f0EB6_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EB6->then_instructions;
+
+ body.emit(assign(r0EB5, r0E7D, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0EB6->else_instructions;
+
+ ir_expression *const r0EB8 = lshift(r0E7D, r0E82);
+ ir_expression *const r0EB9 = neg(r0E82);
+ ir_expression *const r0EBA = bit_and(r0EB9, body.constant(int(31)));
+ ir_expression *const r0EBB = rshift(r0E7E, r0EBA);
+ body.emit(assign(r0EB5, bit_or(r0EB8, r0EBB), 0x01));
+
+
+ body.instructions = f0EB6_parent_instructions;
+ body.emit(f0EB6);
+
+ /* END IF */
+
+ body.emit(assign(r0E80, r0EB5, 0x01));
+
+ body.emit(assign(r0E81, r0EB4, 0x01));
+
+ ir_expression *const r0EBC = expr(ir_unop_i2u, r0E82);
+ body.emit(assign(r0E7F, sub(body.constant(1u), r0EBC), 0x01));
+
+
+ body.instructions = f0E83_parent_instructions;
+ body.emit(f0E83);
+
+ /* END IF */
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+fmul64(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 r0EBD = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "a", ir_var_function_in);
+ sig_parameters.push_tail(r0EBD);
+ ir_variable *const r0EBE = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "b", ir_var_function_in);
+ sig_parameters.push_tail(r0EBE);
+ ir_variable *const r0EBF = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r0EBF, body.constant(true), 0x01));
+
+ ir_variable *const r0EC0 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r0EC1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac2", ir_var_auto);
+ body.emit(r0EC1);
+ ir_variable *const r0EC2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac1", ir_var_auto);
+ body.emit(r0EC2);
+ ir_variable *const r0EC3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac0", ir_var_auto);
+ body.emit(r0EC3);
+ ir_variable *const r0EC4 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "bFrac", ir_var_auto);
+ body.emit(r0EC4);
+ ir_variable *const r0EC5 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "aFrac", ir_var_auto);
+ body.emit(r0EC5);
+ ir_variable *const r0EC6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zExp", ir_var_auto);
+ body.emit(r0EC6);
+ ir_variable *const r0EC7 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bExp", ir_var_auto);
+ body.emit(r0EC7);
+ ir_variable *const r0EC8 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aExp", ir_var_auto);
+ body.emit(r0EC8);
+ ir_variable *const r0EC9 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zSign", ir_var_auto);
+ body.emit(r0EC9);
+ body.emit(assign(r0EC3, body.constant(0u), 0x01));
+
+ body.emit(assign(r0EC2, body.constant(0u), 0x01));
+
+ body.emit(assign(r0EC1, body.constant(0u), 0x01));
+
+ ir_variable *const r0ECA = body.make_temp(glsl_type::uvec2_type, "vec_ctor");
+ body.emit(assign(r0ECA, bit_and(swizzle_x(r0EBD), body.constant(1048575u)), 0x01));
+
+ body.emit(assign(r0ECA, swizzle_y(r0EBD), 0x02));
+
+ body.emit(assign(r0EC5, r0ECA, 0x03));
+
+ ir_variable *const r0ECB = body.make_temp(glsl_type::uint_type, "extractFloat64Exp_retval");
+ ir_expression *const r0ECC = rshift(swizzle_x(r0EBD), body.constant(int(20)));
+ body.emit(assign(r0ECB, bit_and(r0ECC, body.constant(2047u)), 0x01));
+
+ body.emit(assign(r0EC8, r0ECB, 0x01));
+
+ ir_variable *const r0ECD = body.make_temp(glsl_type::uvec2_type, "vec_ctor");
+ body.emit(assign(r0ECD, bit_and(swizzle_x(r0EBE), body.constant(1048575u)), 0x01));
+
+ body.emit(assign(r0ECD, swizzle_y(r0EBE), 0x02));
+
+ body.emit(assign(r0EC4, r0ECD, 0x03));
+
+ ir_variable *const r0ECE = body.make_temp(glsl_type::uint_type, "extractFloat64Exp_retval");
+ ir_expression *const r0ECF = rshift(swizzle_x(r0EBE), body.constant(int(20)));
+ body.emit(assign(r0ECE, bit_and(r0ECF, body.constant(2047u)), 0x01));
+
+ body.emit(assign(r0EC7, r0ECE, 0x01));
+
+ ir_expression *const r0ED0 = rshift(swizzle_x(r0EBD), body.constant(int(31)));
+ ir_expression *const r0ED1 = rshift(swizzle_x(r0EBE), body.constant(int(31)));
+ body.emit(assign(r0EC9, bit_xor(r0ED0, r0ED1), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0ED3 = equal(r0ECB, body.constant(2047u));
+ ir_if *f0ED2 = new(mem_ctx) ir_if(operand(r0ED3).val);
+ exec_list *const f0ED2_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0ED2->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0ED5 = bit_or(swizzle_x(r0ECA), swizzle_y(r0EBD));
+ ir_expression *const r0ED6 = nequal(r0ED5, body.constant(0u));
+ ir_expression *const r0ED7 = equal(r0ECE, body.constant(2047u));
+ ir_expression *const r0ED8 = bit_or(swizzle_x(r0ECD), swizzle_y(r0EBE));
+ ir_expression *const r0ED9 = nequal(r0ED8, body.constant(0u));
+ ir_expression *const r0EDA = logic_and(r0ED7, r0ED9);
+ ir_expression *const r0EDB = logic_or(r0ED6, r0EDA);
+ ir_if *f0ED4 = new(mem_ctx) ir_if(operand(r0EDB).val);
+ exec_list *const f0ED4_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0ED4->then_instructions;
+
+ ir_variable *const r0EDC = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r0EDC, swizzle_x(r0EBD), 0x01));
+
+ ir_variable *const r0EDD = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r0EDD, swizzle_x(r0EBE), 0x01));
+
+ ir_variable *const r0EDE = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r0EDF = body.make_temp(glsl_type::bool_type, "float64_is_signaling_nan_retval");
+ ir_expression *const r0EE0 = rshift(swizzle_y(r0EBD), body.constant(int(19)));
+ ir_expression *const r0EE1 = bit_and(r0EE0, body.constant(4095u));
+ ir_expression *const r0EE2 = equal(r0EE1, body.constant(4094u));
+ ir_expression *const r0EE3 = nequal(swizzle_x(r0EBD), body.constant(0u));
+ ir_expression *const r0EE4 = bit_and(swizzle_y(r0EBD), body.constant(524287u));
+ ir_expression *const r0EE5 = nequal(r0EE4, body.constant(0u));
+ ir_expression *const r0EE6 = logic_or(r0EE3, r0EE5);
+ body.emit(assign(r0EDF, logic_and(r0EE2, r0EE6), 0x01));
+
+ ir_variable *const r0EE7 = body.make_temp(glsl_type::bool_type, "float64_is_nan_retval");
+ ir_expression *const r0EE8 = lshift(swizzle_y(r0EBE), body.constant(int(1)));
+ ir_expression *const r0EE9 = lequal(body.constant(4292870144u), r0EE8);
+ ir_expression *const r0EEA = nequal(swizzle_x(r0EBE), body.constant(0u));
+ ir_expression *const r0EEB = bit_and(swizzle_y(r0EBE), body.constant(1048575u));
+ ir_expression *const r0EEC = nequal(r0EEB, body.constant(0u));
+ ir_expression *const r0EED = logic_or(r0EEA, r0EEC);
+ body.emit(assign(r0EE7, logic_and(r0EE9, r0EED), 0x01));
+
+ body.emit(assign(r0EDC, bit_or(swizzle_y(r0EBD), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r0EDD, bit_or(swizzle_y(r0EBE), body.constant(524288u)), 0x02));
+
+ /* IF CONDITION */
+ ir_expression *const r0EEF = lshift(swizzle_y(r0EBD), body.constant(int(1)));
+ ir_expression *const r0EF0 = lequal(body.constant(4292870144u), r0EEF);
+ ir_expression *const r0EF1 = nequal(swizzle_x(r0EBD), body.constant(0u));
+ ir_expression *const r0EF2 = bit_and(swizzle_y(r0EBD), body.constant(1048575u));
+ ir_expression *const r0EF3 = nequal(r0EF2, body.constant(0u));
+ ir_expression *const r0EF4 = logic_or(r0EF1, r0EF3);
+ ir_expression *const r0EF5 = logic_and(r0EF0, r0EF4);
+ ir_if *f0EEE = new(mem_ctx) ir_if(operand(r0EF5).val);
+ exec_list *const f0EEE_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EEE->then_instructions;
+
+ ir_variable *const r0EF6 = body.make_temp(glsl_type::uvec2_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r0EF8 = logic_and(r0EDF, r0EE7);
+ ir_if *f0EF7 = new(mem_ctx) ir_if(operand(r0EF8).val);
+ exec_list *const f0EF7_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EF7->then_instructions;
+
+ body.emit(assign(r0EF6, r0EDD, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0EF7->else_instructions;
+
+ body.emit(assign(r0EF6, r0EDC, 0x03));
+
+
+ body.instructions = f0EF7_parent_instructions;
+ body.emit(f0EF7);
+
+ /* END IF */
+
+ body.emit(assign(r0EDE, r0EF6, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0EEE->else_instructions;
+
+ body.emit(assign(r0EDE, r0EDD, 0x03));
+
+
+ body.instructions = f0EEE_parent_instructions;
+ body.emit(f0EEE);
+
+ /* END IF */
+
+ body.emit(assign(r0EC0, r0EDE, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0ED4->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0EFA = bit_or(r0ECE, swizzle_x(r0ECD));
+ ir_expression *const r0EFB = bit_or(r0EFA, swizzle_y(r0EBE));
+ ir_expression *const r0EFC = equal(r0EFB, body.constant(0u));
+ ir_if *f0EF9 = new(mem_ctx) ir_if(operand(r0EFC).val);
+ exec_list *const f0EF9_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0EF9->then_instructions;
+
+ ir_constant_data r0EFD_data;
+ memset(&r0EFD_data, 0, sizeof(ir_constant_data));
+r0EFD_data.u[0] = 4294967295;
+r0EFD_data.u[1] = 4294967295;
+ ir_constant *const r0EFD = new(mem_ctx) ir_constant(glsl_type::uvec2_type, &r0EFD_data);
+ body.emit(assign(r0EC0, r0EFD, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0EF9->else_instructions;
+
+ ir_variable *const r0EFE = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0EFE);
+ ir_expression *const r0EFF = lshift(r0EC9, body.constant(int(31)));
+ body.emit(assign(r0EFE, add(r0EFF, body.constant(2146435072u)), 0x01));
+
+ body.emit(assign(r0EFE, body.constant(0u), 0x02));
+
+ body.emit(assign(r0EC0, r0EFE, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ body.instructions = f0EF9_parent_instructions;
+ body.emit(f0EF9);
+
+ /* END IF */
+
+
+ body.instructions = f0ED4_parent_instructions;
+ body.emit(f0ED4);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0ED2->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0F01 = equal(r0ECE, body.constant(2047u));
+ ir_if *f0F00 = new(mem_ctx) ir_if(operand(r0F01).val);
+ exec_list *const f0F00_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F00->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0F03 = bit_or(swizzle_x(r0ECD), swizzle_y(r0EBE));
+ ir_expression *const r0F04 = nequal(r0F03, body.constant(0u));
+ ir_if *f0F02 = new(mem_ctx) ir_if(operand(r0F04).val);
+ exec_list *const f0F02_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F02->then_instructions;
+
+ ir_variable *const r0F05 = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r0F05, swizzle_x(r0EBD), 0x01));
+
+ ir_variable *const r0F06 = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r0F06, swizzle_x(r0EBE), 0x01));
+
+ ir_variable *const r0F07 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r0F08 = body.make_temp(glsl_type::bool_type, "float64_is_signaling_nan_retval");
+ ir_expression *const r0F09 = rshift(swizzle_y(r0EBD), body.constant(int(19)));
+ ir_expression *const r0F0A = bit_and(r0F09, body.constant(4095u));
+ ir_expression *const r0F0B = equal(r0F0A, body.constant(4094u));
+ ir_expression *const r0F0C = nequal(swizzle_x(r0EBD), body.constant(0u));
+ ir_expression *const r0F0D = bit_and(swizzle_y(r0EBD), body.constant(524287u));
+ ir_expression *const r0F0E = nequal(r0F0D, body.constant(0u));
+ ir_expression *const r0F0F = logic_or(r0F0C, r0F0E);
+ body.emit(assign(r0F08, logic_and(r0F0B, r0F0F), 0x01));
+
+ ir_variable *const r0F10 = body.make_temp(glsl_type::bool_type, "float64_is_nan_retval");
+ ir_expression *const r0F11 = lshift(swizzle_y(r0EBE), body.constant(int(1)));
+ ir_expression *const r0F12 = lequal(body.constant(4292870144u), r0F11);
+ ir_expression *const r0F13 = nequal(swizzle_x(r0EBE), body.constant(0u));
+ ir_expression *const r0F14 = bit_and(swizzle_y(r0EBE), body.constant(1048575u));
+ ir_expression *const r0F15 = nequal(r0F14, body.constant(0u));
+ ir_expression *const r0F16 = logic_or(r0F13, r0F15);
+ body.emit(assign(r0F10, logic_and(r0F12, r0F16), 0x01));
+
+ body.emit(assign(r0F05, bit_or(swizzle_y(r0EBD), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r0F06, bit_or(swizzle_y(r0EBE), body.constant(524288u)), 0x02));
+
+ /* IF CONDITION */
+ ir_expression *const r0F18 = lshift(swizzle_y(r0EBD), body.constant(int(1)));
+ ir_expression *const r0F19 = lequal(body.constant(4292870144u), r0F18);
+ ir_expression *const r0F1A = nequal(swizzle_x(r0EBD), body.constant(0u));
+ ir_expression *const r0F1B = bit_and(swizzle_y(r0EBD), body.constant(1048575u));
+ ir_expression *const r0F1C = nequal(r0F1B, body.constant(0u));
+ ir_expression *const r0F1D = logic_or(r0F1A, r0F1C);
+ ir_expression *const r0F1E = logic_and(r0F19, r0F1D);
+ ir_if *f0F17 = new(mem_ctx) ir_if(operand(r0F1E).val);
+ exec_list *const f0F17_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F17->then_instructions;
+
+ ir_variable *const r0F1F = body.make_temp(glsl_type::uvec2_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r0F21 = logic_and(r0F08, r0F10);
+ ir_if *f0F20 = new(mem_ctx) ir_if(operand(r0F21).val);
+ exec_list *const f0F20_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F20->then_instructions;
+
+ body.emit(assign(r0F1F, r0F06, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F20->else_instructions;
+
+ body.emit(assign(r0F1F, r0F05, 0x03));
+
+
+ body.instructions = f0F20_parent_instructions;
+ body.emit(f0F20);
+
+ /* END IF */
+
+ body.emit(assign(r0F07, r0F1F, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F17->else_instructions;
+
+ body.emit(assign(r0F07, r0F06, 0x03));
+
+
+ body.instructions = f0F17_parent_instructions;
+ body.emit(f0F17);
+
+ /* END IF */
+
+ body.emit(assign(r0EC0, r0F07, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F02->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0F23 = bit_or(r0ECB, swizzle_x(r0ECA));
+ ir_expression *const r0F24 = bit_or(r0F23, swizzle_y(r0EBD));
+ ir_expression *const r0F25 = equal(r0F24, body.constant(0u));
+ ir_if *f0F22 = new(mem_ctx) ir_if(operand(r0F25).val);
+ exec_list *const f0F22_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F22->then_instructions;
+
+ ir_constant_data r0F26_data;
+ memset(&r0F26_data, 0, sizeof(ir_constant_data));
+r0F26_data.u[0] = 4294967295;
+r0F26_data.u[1] = 4294967295;
+ ir_constant *const r0F26 = new(mem_ctx) ir_constant(glsl_type::uvec2_type, &r0F26_data);
+ body.emit(assign(r0EC0, r0F26, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F22->else_instructions;
+
+ ir_variable *const r0F27 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0F27);
+ ir_expression *const r0F28 = lshift(r0EC9, body.constant(int(31)));
+ body.emit(assign(r0F27, add(r0F28, body.constant(2146435072u)), 0x01));
+
+ body.emit(assign(r0F27, body.constant(0u), 0x02));
+
+ body.emit(assign(r0EC0, r0F27, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ body.instructions = f0F22_parent_instructions;
+ body.emit(f0F22);
+
+ /* END IF */
+
+
+ body.instructions = f0F02_parent_instructions;
+ body.emit(f0F02);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F00->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0F2A = equal(r0ECB, body.constant(0u));
+ ir_if *f0F29 = new(mem_ctx) ir_if(operand(r0F2A).val);
+ exec_list *const f0F29_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F29->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0F2C = bit_or(swizzle_x(r0ECA), swizzle_y(r0EBD));
+ ir_expression *const r0F2D = equal(r0F2C, body.constant(0u));
+ ir_if *f0F2B = new(mem_ctx) ir_if(operand(r0F2D).val);
+ exec_list *const f0F2B_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F2B->then_instructions;
+
+ ir_variable *const r0F2E = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0F2E);
+ body.emit(assign(r0F2E, lshift(r0EC9, body.constant(int(31))), 0x01));
+
+ body.emit(assign(r0F2E, body.constant(0u), 0x02));
+
+ body.emit(assign(r0EC0, r0F2E, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F2B->else_instructions;
+
+ ir_variable *const r0F2F = body.make_temp(glsl_type::uint_type, "aFrac0");
+ body.emit(assign(r0F2F, swizzle_x(r0ECA), 0x01));
+
+ ir_variable *const r0F30 = body.make_temp(glsl_type::uint_type, "aFrac1");
+ body.emit(assign(r0F30, swizzle_y(r0ECA), 0x01));
+
+ ir_variable *const r0F31 = body.make_temp(glsl_type::uint_type, "zExpPtr");
+ body.emit(assign(r0F31, r0ECB, 0x01));
+
+ ir_variable *const r0F32 = body.make_temp(glsl_type::uint_type, "zFrac0Ptr");
+ body.emit(assign(r0F32, swizzle_x(r0ECA), 0x01));
+
+ ir_variable *const r0F33 = body.make_temp(glsl_type::uint_type, "zFrac1Ptr");
+ body.emit(assign(r0F33, swizzle_y(r0ECA), 0x01));
+
+ ir_variable *const r0F34 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r0F34);
+ /* IF CONDITION */
+ ir_expression *const r0F36 = equal(swizzle_x(r0ECA), body.constant(0u));
+ ir_if *f0F35 = new(mem_ctx) ir_if(operand(r0F36).val);
+ exec_list *const f0F35_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F35->then_instructions;
+
+ ir_variable *const r0F37 = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r0F37, r0F30, 0x01));
+
+ ir_variable *const r0F38 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r0F39 = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r0F39);
+ /* IF CONDITION */
+ ir_expression *const r0F3B = equal(swizzle_y(r0EBD), body.constant(0u));
+ ir_if *f0F3A = new(mem_ctx) ir_if(operand(r0F3B).val);
+ exec_list *const f0F3A_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F3A->then_instructions;
+
+ body.emit(assign(r0F38, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F3A->else_instructions;
+
+ body.emit(assign(r0F39, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0F3D = bit_and(swizzle_y(r0EBD), body.constant(4294901760u));
+ ir_expression *const r0F3E = equal(r0F3D, body.constant(0u));
+ ir_if *f0F3C = new(mem_ctx) ir_if(operand(r0F3E).val);
+ exec_list *const f0F3C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F3C->then_instructions;
+
+ body.emit(assign(r0F39, body.constant(16u), 0x01));
+
+ body.emit(assign(r0F37, lshift(swizzle_y(r0EBD), body.constant(int(16))), 0x01));
+
+
+ body.instructions = f0F3C_parent_instructions;
+ body.emit(f0F3C);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F40 = bit_and(r0F37, body.constant(4278190080u));
+ ir_expression *const r0F41 = equal(r0F40, body.constant(0u));
+ ir_if *f0F3F = new(mem_ctx) ir_if(operand(r0F41).val);
+ exec_list *const f0F3F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F3F->then_instructions;
+
+ body.emit(assign(r0F39, add(r0F39, body.constant(8u)), 0x01));
+
+ body.emit(assign(r0F37, lshift(r0F37, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f0F3F_parent_instructions;
+ body.emit(f0F3F);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F43 = bit_and(r0F37, body.constant(4026531840u));
+ ir_expression *const r0F44 = equal(r0F43, body.constant(0u));
+ ir_if *f0F42 = new(mem_ctx) ir_if(operand(r0F44).val);
+ exec_list *const f0F42_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F42->then_instructions;
+
+ body.emit(assign(r0F39, add(r0F39, body.constant(4u)), 0x01));
+
+ body.emit(assign(r0F37, lshift(r0F37, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f0F42_parent_instructions;
+ body.emit(f0F42);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F46 = bit_and(r0F37, body.constant(3221225472u));
+ ir_expression *const r0F47 = equal(r0F46, body.constant(0u));
+ ir_if *f0F45 = new(mem_ctx) ir_if(operand(r0F47).val);
+ exec_list *const f0F45_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F45->then_instructions;
+
+ body.emit(assign(r0F39, add(r0F39, body.constant(2u)), 0x01));
+
+ body.emit(assign(r0F37, lshift(r0F37, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f0F45_parent_instructions;
+ body.emit(f0F45);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F49 = bit_and(r0F37, body.constant(2147483648u));
+ ir_expression *const r0F4A = equal(r0F49, body.constant(0u));
+ ir_if *f0F48 = new(mem_ctx) ir_if(operand(r0F4A).val);
+ exec_list *const f0F48_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F48->then_instructions;
+
+ body.emit(assign(r0F39, add(r0F39, body.constant(1u)), 0x01));
+
+
+ body.instructions = f0F48_parent_instructions;
+ body.emit(f0F48);
+
+ /* END IF */
+
+ body.emit(assign(r0F38, r0F39, 0x01));
+
+
+ body.instructions = f0F3A_parent_instructions;
+ body.emit(f0F3A);
+
+ /* END IF */
+
+ ir_expression *const r0F4B = expr(ir_unop_u2i, r0F38);
+ body.emit(assign(r0F34, add(r0F4B, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0F4D = less(r0F34, body.constant(int(0)));
+ ir_if *f0F4C = new(mem_ctx) ir_if(operand(r0F4D).val);
+ exec_list *const f0F4C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F4C->then_instructions;
+
+ ir_expression *const r0F4E = neg(r0F34);
+ body.emit(assign(r0F32, rshift(swizzle_y(r0EBD), r0F4E), 0x01));
+
+ ir_expression *const r0F4F = bit_and(r0F34, body.constant(int(31)));
+ body.emit(assign(r0F33, lshift(swizzle_y(r0EBD), r0F4F), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F4C->else_instructions;
+
+ body.emit(assign(r0F32, lshift(swizzle_y(r0EBD), r0F34), 0x01));
+
+ body.emit(assign(r0F33, body.constant(0u), 0x01));
+
+
+ body.instructions = f0F4C_parent_instructions;
+ body.emit(f0F4C);
+
+ /* END IF */
+
+ ir_expression *const r0F50 = sub(body.constant(int(-31)), r0F34);
+ body.emit(assign(r0F31, expr(ir_unop_i2u, r0F50), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F35->else_instructions;
+
+ ir_variable *const r0F51 = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r0F51, r0F2F, 0x01));
+
+ ir_variable *const r0F52 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r0F53 = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r0F53);
+ /* IF CONDITION */
+ ir_expression *const r0F55 = equal(swizzle_x(r0ECA), body.constant(0u));
+ ir_if *f0F54 = new(mem_ctx) ir_if(operand(r0F55).val);
+ exec_list *const f0F54_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F54->then_instructions;
+
+ body.emit(assign(r0F52, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F54->else_instructions;
+
+ body.emit(assign(r0F53, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0F57 = bit_and(swizzle_x(r0ECA), body.constant(4294901760u));
+ ir_expression *const r0F58 = equal(r0F57, body.constant(0u));
+ ir_if *f0F56 = new(mem_ctx) ir_if(operand(r0F58).val);
+ exec_list *const f0F56_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F56->then_instructions;
+
+ body.emit(assign(r0F53, body.constant(16u), 0x01));
+
+ body.emit(assign(r0F51, lshift(swizzle_x(r0ECA), body.constant(int(16))), 0x01));
+
+
+ body.instructions = f0F56_parent_instructions;
+ body.emit(f0F56);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F5A = bit_and(r0F51, body.constant(4278190080u));
+ ir_expression *const r0F5B = equal(r0F5A, body.constant(0u));
+ ir_if *f0F59 = new(mem_ctx) ir_if(operand(r0F5B).val);
+ exec_list *const f0F59_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F59->then_instructions;
+
+ body.emit(assign(r0F53, add(r0F53, body.constant(8u)), 0x01));
+
+ body.emit(assign(r0F51, lshift(r0F51, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f0F59_parent_instructions;
+ body.emit(f0F59);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F5D = bit_and(r0F51, body.constant(4026531840u));
+ ir_expression *const r0F5E = equal(r0F5D, body.constant(0u));
+ ir_if *f0F5C = new(mem_ctx) ir_if(operand(r0F5E).val);
+ exec_list *const f0F5C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F5C->then_instructions;
+
+ body.emit(assign(r0F53, add(r0F53, body.constant(4u)), 0x01));
+
+ body.emit(assign(r0F51, lshift(r0F51, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f0F5C_parent_instructions;
+ body.emit(f0F5C);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F60 = bit_and(r0F51, body.constant(3221225472u));
+ ir_expression *const r0F61 = equal(r0F60, body.constant(0u));
+ ir_if *f0F5F = new(mem_ctx) ir_if(operand(r0F61).val);
+ exec_list *const f0F5F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F5F->then_instructions;
+
+ body.emit(assign(r0F53, add(r0F53, body.constant(2u)), 0x01));
+
+ body.emit(assign(r0F51, lshift(r0F51, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f0F5F_parent_instructions;
+ body.emit(f0F5F);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F63 = bit_and(r0F51, body.constant(2147483648u));
+ ir_expression *const r0F64 = equal(r0F63, body.constant(0u));
+ ir_if *f0F62 = new(mem_ctx) ir_if(operand(r0F64).val);
+ exec_list *const f0F62_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F62->then_instructions;
+
+ body.emit(assign(r0F53, add(r0F53, body.constant(1u)), 0x01));
+
+
+ body.instructions = f0F62_parent_instructions;
+ body.emit(f0F62);
+
+ /* END IF */
+
+ body.emit(assign(r0F52, r0F53, 0x01));
+
+
+ body.instructions = f0F54_parent_instructions;
+ body.emit(f0F54);
+
+ /* END IF */
+
+ ir_expression *const r0F65 = expr(ir_unop_u2i, r0F52);
+ body.emit(assign(r0F34, add(r0F65, body.constant(int(-11))), 0x01));
+
+ ir_variable *const r0F66 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r0F66, lshift(swizzle_y(r0EBD), r0F34), 0x01));
+
+ ir_variable *const r0F67 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r0F69 = equal(r0F34, body.constant(int(0)));
+ ir_if *f0F68 = new(mem_ctx) ir_if(operand(r0F69).val);
+ exec_list *const f0F68_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F68->then_instructions;
+
+ body.emit(assign(r0F67, r0F2F, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F68->else_instructions;
+
+ ir_expression *const r0F6A = lshift(swizzle_x(r0ECA), r0F34);
+ ir_expression *const r0F6B = neg(r0F34);
+ ir_expression *const r0F6C = bit_and(r0F6B, body.constant(int(31)));
+ ir_expression *const r0F6D = rshift(swizzle_y(r0EBD), r0F6C);
+ body.emit(assign(r0F67, bit_or(r0F6A, r0F6D), 0x01));
+
+
+ body.instructions = f0F68_parent_instructions;
+ body.emit(f0F68);
+
+ /* END IF */
+
+ body.emit(assign(r0F32, r0F67, 0x01));
+
+ body.emit(assign(r0F33, r0F66, 0x01));
+
+ ir_expression *const r0F6E = expr(ir_unop_i2u, r0F34);
+ body.emit(assign(r0F31, sub(body.constant(1u), r0F6E), 0x01));
+
+
+ body.instructions = f0F35_parent_instructions;
+ body.emit(f0F35);
+
+ /* END IF */
+
+ body.emit(assign(r0EC8, r0F31, 0x01));
+
+ body.emit(assign(r0EC5, r0F32, 0x01));
+
+ body.emit(assign(r0EC5, r0F33, 0x02));
+
+
+ body.instructions = f0F2B_parent_instructions;
+ body.emit(f0F2B);
+
+ /* END IF */
+
+
+ body.instructions = f0F29_parent_instructions;
+ body.emit(f0F29);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f0F6F = new(mem_ctx) ir_if(operand(r0EBF).val);
+ exec_list *const f0F6F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F6F->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0F71 = equal(r0ECE, body.constant(0u));
+ ir_if *f0F70 = new(mem_ctx) ir_if(operand(r0F71).val);
+ exec_list *const f0F70_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F70->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r0F73 = bit_or(swizzle_x(r0ECD), swizzle_y(r0EBE));
+ ir_expression *const r0F74 = equal(r0F73, body.constant(0u));
+ ir_if *f0F72 = new(mem_ctx) ir_if(operand(r0F74).val);
+ exec_list *const f0F72_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F72->then_instructions;
+
+ ir_variable *const r0F75 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r0F75);
+ body.emit(assign(r0F75, lshift(r0EC9, body.constant(int(31))), 0x01));
+
+ body.emit(assign(r0F75, body.constant(0u), 0x02));
+
+ body.emit(assign(r0EC0, r0F75, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F72->else_instructions;
+
+ ir_variable *const r0F76 = body.make_temp(glsl_type::uint_type, "aFrac0");
+ body.emit(assign(r0F76, swizzle_x(r0ECD), 0x01));
+
+ ir_variable *const r0F77 = body.make_temp(glsl_type::uint_type, "aFrac1");
+ body.emit(assign(r0F77, swizzle_y(r0ECD), 0x01));
+
+ ir_variable *const r0F78 = body.make_temp(glsl_type::uint_type, "zExpPtr");
+ body.emit(assign(r0F78, r0ECE, 0x01));
+
+ ir_variable *const r0F79 = body.make_temp(glsl_type::uint_type, "zFrac0Ptr");
+ body.emit(assign(r0F79, swizzle_x(r0ECD), 0x01));
+
+ ir_variable *const r0F7A = body.make_temp(glsl_type::uint_type, "zFrac1Ptr");
+ body.emit(assign(r0F7A, swizzle_y(r0ECD), 0x01));
+
+ ir_variable *const r0F7B = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r0F7B);
+ /* IF CONDITION */
+ ir_expression *const r0F7D = equal(swizzle_x(r0ECD), body.constant(0u));
+ ir_if *f0F7C = new(mem_ctx) ir_if(operand(r0F7D).val);
+ exec_list *const f0F7C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F7C->then_instructions;
+
+ ir_variable *const r0F7E = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r0F7E, r0F77, 0x01));
+
+ ir_variable *const r0F7F = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r0F80 = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r0F80);
+ /* IF CONDITION */
+ ir_expression *const r0F82 = equal(swizzle_y(r0EBE), body.constant(0u));
+ ir_if *f0F81 = new(mem_ctx) ir_if(operand(r0F82).val);
+ exec_list *const f0F81_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F81->then_instructions;
+
+ body.emit(assign(r0F7F, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F81->else_instructions;
+
+ body.emit(assign(r0F80, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0F84 = bit_and(swizzle_y(r0EBE), body.constant(4294901760u));
+ ir_expression *const r0F85 = equal(r0F84, body.constant(0u));
+ ir_if *f0F83 = new(mem_ctx) ir_if(operand(r0F85).val);
+ exec_list *const f0F83_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F83->then_instructions;
+
+ body.emit(assign(r0F80, body.constant(16u), 0x01));
+
+ body.emit(assign(r0F7E, lshift(swizzle_y(r0EBE), body.constant(int(16))), 0x01));
+
+
+ body.instructions = f0F83_parent_instructions;
+ body.emit(f0F83);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F87 = bit_and(r0F7E, body.constant(4278190080u));
+ ir_expression *const r0F88 = equal(r0F87, body.constant(0u));
+ ir_if *f0F86 = new(mem_ctx) ir_if(operand(r0F88).val);
+ exec_list *const f0F86_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F86->then_instructions;
+
+ body.emit(assign(r0F80, add(r0F80, body.constant(8u)), 0x01));
+
+ body.emit(assign(r0F7E, lshift(r0F7E, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f0F86_parent_instructions;
+ body.emit(f0F86);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F8A = bit_and(r0F7E, body.constant(4026531840u));
+ ir_expression *const r0F8B = equal(r0F8A, body.constant(0u));
+ ir_if *f0F89 = new(mem_ctx) ir_if(operand(r0F8B).val);
+ exec_list *const f0F89_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F89->then_instructions;
+
+ body.emit(assign(r0F80, add(r0F80, body.constant(4u)), 0x01));
+
+ body.emit(assign(r0F7E, lshift(r0F7E, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f0F89_parent_instructions;
+ body.emit(f0F89);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F8D = bit_and(r0F7E, body.constant(3221225472u));
+ ir_expression *const r0F8E = equal(r0F8D, body.constant(0u));
+ ir_if *f0F8C = new(mem_ctx) ir_if(operand(r0F8E).val);
+ exec_list *const f0F8C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F8C->then_instructions;
+
+ body.emit(assign(r0F80, add(r0F80, body.constant(2u)), 0x01));
+
+ body.emit(assign(r0F7E, lshift(r0F7E, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f0F8C_parent_instructions;
+ body.emit(f0F8C);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0F90 = bit_and(r0F7E, body.constant(2147483648u));
+ ir_expression *const r0F91 = equal(r0F90, body.constant(0u));
+ ir_if *f0F8F = new(mem_ctx) ir_if(operand(r0F91).val);
+ exec_list *const f0F8F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F8F->then_instructions;
+
+ body.emit(assign(r0F80, add(r0F80, body.constant(1u)), 0x01));
+
+
+ body.instructions = f0F8F_parent_instructions;
+ body.emit(f0F8F);
+
+ /* END IF */
+
+ body.emit(assign(r0F7F, r0F80, 0x01));
+
+
+ body.instructions = f0F81_parent_instructions;
+ body.emit(f0F81);
+
+ /* END IF */
+
+ ir_expression *const r0F92 = expr(ir_unop_u2i, r0F7F);
+ body.emit(assign(r0F7B, add(r0F92, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0F94 = less(r0F7B, body.constant(int(0)));
+ ir_if *f0F93 = new(mem_ctx) ir_if(operand(r0F94).val);
+ exec_list *const f0F93_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F93->then_instructions;
+
+ ir_expression *const r0F95 = neg(r0F7B);
+ body.emit(assign(r0F79, rshift(swizzle_y(r0EBE), r0F95), 0x01));
+
+ ir_expression *const r0F96 = bit_and(r0F7B, body.constant(int(31)));
+ body.emit(assign(r0F7A, lshift(swizzle_y(r0EBE), r0F96), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F93->else_instructions;
+
+ body.emit(assign(r0F79, lshift(swizzle_y(r0EBE), r0F7B), 0x01));
+
+ body.emit(assign(r0F7A, body.constant(0u), 0x01));
+
+
+ body.instructions = f0F93_parent_instructions;
+ body.emit(f0F93);
+
+ /* END IF */
+
+ ir_expression *const r0F97 = sub(body.constant(int(-31)), r0F7B);
+ body.emit(assign(r0F78, expr(ir_unop_i2u, r0F97), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F7C->else_instructions;
+
+ ir_variable *const r0F98 = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r0F98, r0F76, 0x01));
+
+ ir_variable *const r0F99 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r0F9A = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r0F9A);
+ /* IF CONDITION */
+ ir_expression *const r0F9C = equal(swizzle_x(r0ECD), body.constant(0u));
+ ir_if *f0F9B = new(mem_ctx) ir_if(operand(r0F9C).val);
+ exec_list *const f0F9B_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F9B->then_instructions;
+
+ body.emit(assign(r0F99, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0F9B->else_instructions;
+
+ body.emit(assign(r0F9A, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r0F9E = bit_and(swizzle_x(r0ECD), body.constant(4294901760u));
+ ir_expression *const r0F9F = equal(r0F9E, body.constant(0u));
+ ir_if *f0F9D = new(mem_ctx) ir_if(operand(r0F9F).val);
+ exec_list *const f0F9D_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0F9D->then_instructions;
+
+ body.emit(assign(r0F9A, body.constant(16u), 0x01));
+
+ body.emit(assign(r0F98, lshift(swizzle_x(r0ECD), body.constant(int(16))), 0x01));
+
+
+ body.instructions = f0F9D_parent_instructions;
+ body.emit(f0F9D);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0FA1 = bit_and(r0F98, body.constant(4278190080u));
+ ir_expression *const r0FA2 = equal(r0FA1, body.constant(0u));
+ ir_if *f0FA0 = new(mem_ctx) ir_if(operand(r0FA2).val);
+ exec_list *const f0FA0_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0FA0->then_instructions;
+
+ body.emit(assign(r0F9A, add(r0F9A, body.constant(8u)), 0x01));
+
+ body.emit(assign(r0F98, lshift(r0F98, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f0FA0_parent_instructions;
+ body.emit(f0FA0);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0FA4 = bit_and(r0F98, body.constant(4026531840u));
+ ir_expression *const r0FA5 = equal(r0FA4, body.constant(0u));
+ ir_if *f0FA3 = new(mem_ctx) ir_if(operand(r0FA5).val);
+ exec_list *const f0FA3_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0FA3->then_instructions;
+
+ body.emit(assign(r0F9A, add(r0F9A, body.constant(4u)), 0x01));
+
+ body.emit(assign(r0F98, lshift(r0F98, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f0FA3_parent_instructions;
+ body.emit(f0FA3);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0FA7 = bit_and(r0F98, body.constant(3221225472u));
+ ir_expression *const r0FA8 = equal(r0FA7, body.constant(0u));
+ ir_if *f0FA6 = new(mem_ctx) ir_if(operand(r0FA8).val);
+ exec_list *const f0FA6_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0FA6->then_instructions;
+
+ body.emit(assign(r0F9A, add(r0F9A, body.constant(2u)), 0x01));
+
+ body.emit(assign(r0F98, lshift(r0F98, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f0FA6_parent_instructions;
+ body.emit(f0FA6);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r0FAA = bit_and(r0F98, body.constant(2147483648u));
+ ir_expression *const r0FAB = equal(r0FAA, body.constant(0u));
+ ir_if *f0FA9 = new(mem_ctx) ir_if(operand(r0FAB).val);
+ exec_list *const f0FA9_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0FA9->then_instructions;
+
+ body.emit(assign(r0F9A, add(r0F9A, body.constant(1u)), 0x01));
+
+
+ body.instructions = f0FA9_parent_instructions;
+ body.emit(f0FA9);
+
+ /* END IF */
+
+ body.emit(assign(r0F99, r0F9A, 0x01));
+
+
+ body.instructions = f0F9B_parent_instructions;
+ body.emit(f0F9B);
+
+ /* END IF */
+
+ ir_expression *const r0FAC = expr(ir_unop_u2i, r0F99);
+ body.emit(assign(r0F7B, add(r0FAC, body.constant(int(-11))), 0x01));
+
+ ir_variable *const r0FAD = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r0FAD, lshift(swizzle_y(r0EBE), r0F7B), 0x01));
+
+ ir_variable *const r0FAE = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r0FB0 = equal(r0F7B, body.constant(int(0)));
+ ir_if *f0FAF = new(mem_ctx) ir_if(operand(r0FB0).val);
+ exec_list *const f0FAF_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0FAF->then_instructions;
+
+ body.emit(assign(r0FAE, r0F76, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f0FAF->else_instructions;
+
+ ir_expression *const r0FB1 = lshift(swizzle_x(r0ECD), r0F7B);
+ ir_expression *const r0FB2 = neg(r0F7B);
+ ir_expression *const r0FB3 = bit_and(r0FB2, body.constant(int(31)));
+ ir_expression *const r0FB4 = rshift(swizzle_y(r0EBE), r0FB3);
+ body.emit(assign(r0FAE, bit_or(r0FB1, r0FB4), 0x01));
+
+
+ body.instructions = f0FAF_parent_instructions;
+ body.emit(f0FAF);
+
+ /* END IF */
+
+ body.emit(assign(r0F79, r0FAE, 0x01));
+
+ body.emit(assign(r0F7A, r0FAD, 0x01));
+
+ ir_expression *const r0FB5 = expr(ir_unop_i2u, r0F7B);
+ body.emit(assign(r0F78, sub(body.constant(1u), r0FB5), 0x01));
+
+
+ body.instructions = f0F7C_parent_instructions;
+ body.emit(f0F7C);
+
+ /* END IF */
+
+ body.emit(assign(r0EC7, r0F78, 0x01));
+
+ body.emit(assign(r0EC4, r0F79, 0x01));
+
+ body.emit(assign(r0EC4, r0F7A, 0x02));
+
+
+ body.instructions = f0F72_parent_instructions;
+ body.emit(f0F72);
+
+ /* END IF */
+
+
+ body.instructions = f0F70_parent_instructions;
+ body.emit(f0F70);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f0FB6 = new(mem_ctx) ir_if(operand(r0EBF).val);
+ exec_list *const f0FB6_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f0FB6->then_instructions;
+
+ ir_expression *const r0FB7 = add(r0EC8, r0EC7);
+ ir_expression *const r0FB8 = expr(ir_unop_u2i, r0FB7);
+ ir_expression *const r0FB9 = add(r0FB8, body.constant(int(-1024)));
+ body.emit(assign(r0EC6, expr(ir_unop_i2u, r0FB9), 0x01));
+
+ body.emit(assign(r0EC5, bit_or(swizzle_x(r0EC5), body.constant(1048576u)), 0x01));
+
+ ir_variable *const r0FBA = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r0FBA, lshift(swizzle_y(r0EC4), body.constant(int(12))), 0x01));
+
+ ir_variable *const r0FBB = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ ir_expression *const r0FBC = lshift(swizzle_x(r0EC4), body.constant(int(12)));
+ ir_expression *const r0FBD = rshift(swizzle_y(r0EC4), body.constant(int(20)));
+ body.emit(assign(r0FBB, bit_or(r0FBC, r0FBD), 0x01));
+
+ body.emit(assign(r0EC4, r0FBB, 0x01));
+
+ body.emit(assign(r0EC4, r0FBA, 0x02));
+
+ ir_variable *const r0FBE = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0FBE);
+ ir_variable *const r0FBF = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0FBF);
+ ir_variable *const r0FC0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0FC0);
+ ir_variable *const r0FC1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0FC1);
+ ir_variable *const r0FC2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0FC2);
+ ir_variable *const r0FC3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0FC3);
+ body.emit(assign(r0FC3, rshift(swizzle_y(r0EC5), body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FC2, rshift(r0FBA, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FBE, mul(swizzle_y(r0EC5), r0FBA), 0x01));
+
+ body.emit(assign(r0FC0, mul(swizzle_y(r0EC5), r0FC2), 0x01));
+
+ body.emit(assign(r0FBF, mul(r0FC3, r0FBA), 0x01));
+
+ body.emit(assign(r0FC1, mul(r0FC3, r0FC2), 0x01));
+
+ body.emit(assign(r0FC0, add(r0FC0, r0FBF), 0x01));
+
+ ir_expression *const r0FC4 = less(r0FC0, r0FBF);
+ ir_expression *const r0FC5 = expr(ir_unop_b2i, r0FC4);
+ ir_expression *const r0FC6 = expr(ir_unop_i2u, r0FC5);
+ ir_expression *const r0FC7 = lshift(r0FC6, body.constant(int(16)));
+ ir_expression *const r0FC8 = rshift(r0FC0, body.constant(int(16)));
+ ir_expression *const r0FC9 = add(r0FC7, r0FC8);
+ body.emit(assign(r0FC1, add(r0FC1, r0FC9), 0x01));
+
+ body.emit(assign(r0FC0, lshift(r0FC0, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FBE, add(r0FBE, r0FC0), 0x01));
+
+ ir_expression *const r0FCA = less(r0FBE, r0FC0);
+ ir_expression *const r0FCB = expr(ir_unop_b2i, r0FCA);
+ ir_expression *const r0FCC = expr(ir_unop_i2u, r0FCB);
+ body.emit(assign(r0FC1, add(r0FC1, r0FCC), 0x01));
+
+ ir_variable *const r0FCD = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0FCD);
+ ir_variable *const r0FCE = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0FCE);
+ ir_variable *const r0FCF = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0FCF);
+ ir_variable *const r0FD0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0FD0);
+ ir_variable *const r0FD1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0FD1);
+ ir_variable *const r0FD2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0FD2);
+ body.emit(assign(r0FD2, rshift(swizzle_y(r0EC5), body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FD1, rshift(r0FBB, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FCD, mul(swizzle_y(r0EC5), r0FBB), 0x01));
+
+ body.emit(assign(r0FCF, mul(swizzle_y(r0EC5), r0FD1), 0x01));
+
+ body.emit(assign(r0FCE, mul(r0FD2, r0FBB), 0x01));
+
+ body.emit(assign(r0FD0, mul(r0FD2, r0FD1), 0x01));
+
+ body.emit(assign(r0FCF, add(r0FCF, r0FCE), 0x01));
+
+ ir_expression *const r0FD3 = less(r0FCF, r0FCE);
+ ir_expression *const r0FD4 = expr(ir_unop_b2i, r0FD3);
+ ir_expression *const r0FD5 = expr(ir_unop_i2u, r0FD4);
+ ir_expression *const r0FD6 = lshift(r0FD5, body.constant(int(16)));
+ ir_expression *const r0FD7 = rshift(r0FCF, body.constant(int(16)));
+ ir_expression *const r0FD8 = add(r0FD6, r0FD7);
+ body.emit(assign(r0FD0, add(r0FD0, r0FD8), 0x01));
+
+ body.emit(assign(r0FCF, lshift(r0FCF, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FCD, add(r0FCD, r0FCF), 0x01));
+
+ ir_expression *const r0FD9 = less(r0FCD, r0FCF);
+ ir_expression *const r0FDA = expr(ir_unop_b2i, r0FD9);
+ ir_expression *const r0FDB = expr(ir_unop_i2u, r0FDA);
+ body.emit(assign(r0FD0, add(r0FD0, r0FDB), 0x01));
+
+ ir_variable *const r0FDC = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0FDC);
+ body.emit(assign(r0FDC, add(r0FCD, r0FC1), 0x01));
+
+ ir_variable *const r0FDD = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0FDD);
+ ir_variable *const r0FDE = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0FDE);
+ ir_variable *const r0FDF = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0FDF);
+ ir_variable *const r0FE0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0FE0);
+ ir_variable *const r0FE1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0FE1);
+ ir_variable *const r0FE2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0FE2);
+ body.emit(assign(r0FE2, rshift(swizzle_x(r0EC5), body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FE1, rshift(r0FBB, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FDD, mul(swizzle_x(r0EC5), r0FBB), 0x01));
+
+ body.emit(assign(r0FDF, mul(swizzle_x(r0EC5), r0FE1), 0x01));
+
+ body.emit(assign(r0FDE, mul(r0FE2, r0FBB), 0x01));
+
+ body.emit(assign(r0FE0, mul(r0FE2, r0FE1), 0x01));
+
+ body.emit(assign(r0FDF, add(r0FDF, r0FDE), 0x01));
+
+ ir_expression *const r0FE3 = less(r0FDF, r0FDE);
+ ir_expression *const r0FE4 = expr(ir_unop_b2i, r0FE3);
+ ir_expression *const r0FE5 = expr(ir_unop_i2u, r0FE4);
+ ir_expression *const r0FE6 = lshift(r0FE5, body.constant(int(16)));
+ ir_expression *const r0FE7 = rshift(r0FDF, body.constant(int(16)));
+ ir_expression *const r0FE8 = add(r0FE6, r0FE7);
+ body.emit(assign(r0FE0, add(r0FE0, r0FE8), 0x01));
+
+ body.emit(assign(r0FDF, lshift(r0FDF, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FDD, add(r0FDD, r0FDF), 0x01));
+
+ ir_expression *const r0FE9 = less(r0FDD, r0FDF);
+ ir_expression *const r0FEA = expr(ir_unop_b2i, r0FE9);
+ ir_expression *const r0FEB = expr(ir_unop_i2u, r0FEA);
+ body.emit(assign(r0FE0, add(r0FE0, r0FEB), 0x01));
+
+ ir_variable *const r0FEC = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0FEC);
+ ir_expression *const r0FED = less(r0FDC, r0FCD);
+ ir_expression *const r0FEE = expr(ir_unop_b2i, r0FED);
+ ir_expression *const r0FEF = expr(ir_unop_i2u, r0FEE);
+ ir_expression *const r0FF0 = add(r0FD0, r0FEF);
+ body.emit(assign(r0FEC, add(r0FDD, r0FF0), 0x01));
+
+ ir_variable *const r0FF1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r0FF1);
+ ir_variable *const r0FF2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r0FF2);
+ ir_variable *const r0FF3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r0FF3);
+ ir_variable *const r0FF4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r0FF4);
+ ir_variable *const r0FF5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r0FF5);
+ ir_variable *const r0FF6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r0FF6);
+ body.emit(assign(r0FF6, rshift(swizzle_x(r0EC5), body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FF5, rshift(r0FBA, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FF1, mul(swizzle_x(r0EC5), r0FBA), 0x01));
+
+ body.emit(assign(r0FF3, mul(swizzle_x(r0EC5), r0FF5), 0x01));
+
+ body.emit(assign(r0FF2, mul(r0FF6, r0FBA), 0x01));
+
+ body.emit(assign(r0FF4, mul(r0FF6, r0FF5), 0x01));
+
+ body.emit(assign(r0FF3, add(r0FF3, r0FF2), 0x01));
+
+ ir_expression *const r0FF7 = less(r0FF3, r0FF2);
+ ir_expression *const r0FF8 = expr(ir_unop_b2i, r0FF7);
+ ir_expression *const r0FF9 = expr(ir_unop_i2u, r0FF8);
+ ir_expression *const r0FFA = lshift(r0FF9, body.constant(int(16)));
+ ir_expression *const r0FFB = rshift(r0FF3, body.constant(int(16)));
+ ir_expression *const r0FFC = add(r0FFA, r0FFB);
+ body.emit(assign(r0FF4, add(r0FF4, r0FFC), 0x01));
+
+ body.emit(assign(r0FF3, lshift(r0FF3, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r0FF1, add(r0FF1, r0FF3), 0x01));
+
+ ir_expression *const r0FFD = less(r0FF1, r0FF3);
+ ir_expression *const r0FFE = expr(ir_unop_b2i, r0FFD);
+ ir_expression *const r0FFF = expr(ir_unop_i2u, r0FFE);
+ body.emit(assign(r0FF4, add(r0FF4, r0FFF), 0x01));
+
+ ir_variable *const r1000 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1000);
+ body.emit(assign(r1000, add(r0FF1, r0FDC), 0x01));
+
+ ir_variable *const r1001 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1001);
+ ir_expression *const r1002 = less(r1000, r0FF1);
+ ir_expression *const r1003 = expr(ir_unop_b2i, r1002);
+ ir_expression *const r1004 = expr(ir_unop_i2u, r1003);
+ ir_expression *const r1005 = add(r0FF4, r1004);
+ body.emit(assign(r1001, add(r0FEC, r1005), 0x01));
+
+ ir_variable *const r1006 = body.make_temp(glsl_type::uint_type, "z0Ptr");
+ ir_variable *const r1007 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1007);
+ body.emit(assign(r1007, add(r1001, swizzle_y(r0EC5)), 0x01));
+
+ ir_expression *const r1008 = less(r0FEC, r0FDD);
+ ir_expression *const r1009 = expr(ir_unop_b2i, r1008);
+ ir_expression *const r100A = expr(ir_unop_i2u, r1009);
+ ir_expression *const r100B = add(r0FE0, r100A);
+ ir_expression *const r100C = less(r1001, r0FEC);
+ ir_expression *const r100D = expr(ir_unop_b2i, r100C);
+ ir_expression *const r100E = expr(ir_unop_i2u, r100D);
+ ir_expression *const r100F = add(r100B, r100E);
+ ir_expression *const r1010 = add(r100F, swizzle_x(r0EC5));
+ ir_expression *const r1011 = less(r1007, r1001);
+ ir_expression *const r1012 = expr(ir_unop_b2i, r1011);
+ ir_expression *const r1013 = expr(ir_unop_i2u, r1012);
+ body.emit(assign(r1006, add(r1010, r1013), 0x01));
+
+ body.emit(assign(r0EC3, r1006, 0x01));
+
+ body.emit(assign(r0EC2, r1007, 0x01));
+
+ ir_expression *const r1014 = nequal(r0FBE, body.constant(0u));
+ ir_expression *const r1015 = expr(ir_unop_b2i, r1014);
+ ir_expression *const r1016 = expr(ir_unop_i2u, r1015);
+ body.emit(assign(r0EC1, bit_or(r1000, r1016), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r1018 = lequal(body.constant(2097152u), r1006);
+ ir_if *f1017 = new(mem_ctx) ir_if(operand(r1018).val);
+ exec_list *const f1017_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1017->then_instructions;
+
+ ir_variable *const r1019 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r1019);
+ body.emit(assign(r1019, lshift(r1007, body.constant(int(31))), 0x01));
+
+ ir_expression *const r101A = nequal(r0EC1, body.constant(0u));
+ ir_expression *const r101B = expr(ir_unop_b2i, r101A);
+ ir_expression *const r101C = expr(ir_unop_i2u, r101B);
+ body.emit(assign(r1019, bit_or(r1019, r101C), 0x01));
+
+ body.emit(assign(r0EC3, rshift(r1006, body.constant(int(1))), 0x01));
+
+ ir_expression *const r101D = lshift(r1006, body.constant(int(31)));
+ ir_expression *const r101E = rshift(r1007, body.constant(int(1)));
+ body.emit(assign(r0EC2, bit_or(r101D, r101E), 0x01));
+
+ body.emit(assign(r0EC1, r1019, 0x01));
+
+ body.emit(assign(r0EC6, add(r0EC6, body.constant(1u)), 0x01));
+
+
+ body.instructions = f1017_parent_instructions;
+ body.emit(f1017);
+
+ /* END IF */
+
+ ir_variable *const r101F = body.make_temp(glsl_type::uint_type, "zExp");
+ body.emit(assign(r101F, r0EC6, 0x01));
+
+ ir_variable *const r1020 = body.make_temp(glsl_type::uint_type, "zFrac0");
+ body.emit(assign(r1020, r0EC3, 0x01));
+
+ ir_variable *const r1021 = body.make_temp(glsl_type::uint_type, "zFrac1");
+ body.emit(assign(r1021, r0EC2, 0x01));
+
+ ir_variable *const r1022 = body.make_temp(glsl_type::uint_type, "zFrac2");
+ body.emit(assign(r1022, r0EC1, 0x01));
+
+ ir_variable *const r1023 = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r1023, body.constant(true), 0x01));
+
+ ir_variable *const r1024 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r1025 = new(mem_ctx) ir_variable(glsl_type::uint_type, "increment", ir_var_auto);
+ body.emit(r1025);
+ ir_expression *const r1026 = less(r0EC1, body.constant(0u));
+ ir_expression *const r1027 = expr(ir_unop_b2i, r1026);
+ body.emit(assign(r1025, expr(ir_unop_i2u, r1027), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r1029 = lequal(body.constant(2045u), r0EC6);
+ ir_if *f1028 = new(mem_ctx) ir_if(operand(r1029).val);
+ exec_list *const f1028_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1028->then_instructions;
+
+ ir_variable *const r102A = body.make_temp(glsl_type::bool_type, "or_tmp");
+ /* IF CONDITION */
+ ir_expression *const r102C = less(body.constant(2045u), r0EC6);
+ ir_if *f102B = new(mem_ctx) ir_if(operand(r102C).val);
+ exec_list *const f102B_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f102B->then_instructions;
+
+ body.emit(assign(r102A, body.constant(true), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f102B->else_instructions;
+
+ ir_variable *const r102D = body.make_temp(glsl_type::bool_type, "and_tmp");
+ /* IF CONDITION */
+ ir_expression *const r102F = equal(r0EC6, body.constant(2045u));
+ ir_if *f102E = new(mem_ctx) ir_if(operand(r102F).val);
+ exec_list *const f102E_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f102E->then_instructions;
+
+ ir_expression *const r1030 = equal(body.constant(2097151u), r0EC3);
+ ir_expression *const r1031 = equal(body.constant(4294967295u), r0EC2);
+ body.emit(assign(r102D, logic_and(r1030, r1031), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f102E->else_instructions;
+
+ body.emit(assign(r102D, body.constant(false), 0x01));
+
+
+ body.instructions = f102E_parent_instructions;
+ body.emit(f102E);
+
+ /* END IF */
+
+ ir_expression *const r1032 = nequal(r1025, body.constant(0u));
+ body.emit(assign(r102A, logic_and(r102D, r1032), 0x01));
+
+
+ body.instructions = f102B_parent_instructions;
+ body.emit(f102B);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f1033 = new(mem_ctx) ir_if(operand(r102A).val);
+ exec_list *const f1033_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1033->then_instructions;
+
+ ir_variable *const r1034 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r1034);
+ ir_expression *const r1035 = lshift(r0EC9, body.constant(int(31)));
+ body.emit(assign(r1034, add(r1035, body.constant(2146435072u)), 0x01));
+
+ body.emit(assign(r1034, body.constant(0u), 0x02));
+
+ body.emit(assign(r1024, r1034, 0x03));
+
+ body.emit(assign(r1023, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1033->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1037 = less(r0EC6, body.constant(0u));
+ ir_if *f1036 = new(mem_ctx) ir_if(operand(r1037).val);
+ exec_list *const f1036_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1036->then_instructions;
+
+ ir_variable *const r1038 = body.make_temp(glsl_type::uint_type, "a2");
+ body.emit(assign(r1038, r0EC1, 0x01));
+
+ ir_variable *const r1039 = body.make_temp(glsl_type::int_type, "count");
+ ir_expression *const r103A = neg(r0EC6);
+ body.emit(assign(r1039, expr(ir_unop_u2i, r103A), 0x01));
+
+ ir_variable *const r103B = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r103B);
+ ir_variable *const r103C = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r103C);
+ ir_variable *const r103D = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r103D);
+ ir_variable *const r103E = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r103F = neg(r1039);
+ body.emit(assign(r103E, bit_and(r103F, body.constant(int(31))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r1041 = equal(r1039, body.constant(int(0)));
+ ir_if *f1040 = new(mem_ctx) ir_if(operand(r1041).val);
+ exec_list *const f1040_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1040->then_instructions;
+
+ body.emit(assign(r103B, r0EC1, 0x01));
+
+ body.emit(assign(r103C, r0EC2, 0x01));
+
+ body.emit(assign(r103D, r0EC3, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1040->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1043 = less(r1039, body.constant(int(32)));
+ ir_if *f1042 = new(mem_ctx) ir_if(operand(r1043).val);
+ exec_list *const f1042_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1042->then_instructions;
+
+ body.emit(assign(r103B, lshift(r0EC2, r103E), 0x01));
+
+ ir_expression *const r1044 = lshift(r0EC3, r103E);
+ ir_expression *const r1045 = rshift(r0EC2, r1039);
+ body.emit(assign(r103C, bit_or(r1044, r1045), 0x01));
+
+ body.emit(assign(r103D, rshift(r0EC3, r1039), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1042->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1047 = equal(r1039, body.constant(int(32)));
+ ir_if *f1046 = new(mem_ctx) ir_if(operand(r1047).val);
+ exec_list *const f1046_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1046->then_instructions;
+
+ body.emit(assign(r103B, r0EC2, 0x01));
+
+ body.emit(assign(r103C, r0EC3, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1046->else_instructions;
+
+ body.emit(assign(r1038, bit_or(r0EC1, r0EC2), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r1049 = less(r1039, body.constant(int(64)));
+ ir_if *f1048 = new(mem_ctx) ir_if(operand(r1049).val);
+ exec_list *const f1048_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1048->then_instructions;
+
+ body.emit(assign(r103B, lshift(r0EC3, r103E), 0x01));
+
+ ir_expression *const r104A = bit_and(r1039, body.constant(int(31)));
+ body.emit(assign(r103C, rshift(r0EC3, r104A), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1048->else_instructions;
+
+ ir_variable *const r104B = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r104D = equal(r1039, body.constant(int(64)));
+ ir_if *f104C = new(mem_ctx) ir_if(operand(r104D).val);
+ exec_list *const f104C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f104C->then_instructions;
+
+ body.emit(assign(r104B, r0EC3, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f104C->else_instructions;
+
+ ir_expression *const r104E = nequal(r0EC3, body.constant(0u));
+ ir_expression *const r104F = expr(ir_unop_b2i, r104E);
+ body.emit(assign(r104B, expr(ir_unop_i2u, r104F), 0x01));
+
+
+ body.instructions = f104C_parent_instructions;
+ body.emit(f104C);
+
+ /* END IF */
+
+ body.emit(assign(r103B, r104B, 0x01));
+
+ body.emit(assign(r103C, body.constant(0u), 0x01));
+
+
+ body.instructions = f1048_parent_instructions;
+ body.emit(f1048);
+
+ /* END IF */
+
+
+ body.instructions = f1046_parent_instructions;
+ body.emit(f1046);
+
+ /* END IF */
+
+ body.emit(assign(r103D, body.constant(0u), 0x01));
+
+
+ body.instructions = f1042_parent_instructions;
+ body.emit(f1042);
+
+ /* END IF */
+
+ ir_expression *const r1050 = nequal(r1038, body.constant(0u));
+ ir_expression *const r1051 = expr(ir_unop_b2i, r1050);
+ ir_expression *const r1052 = expr(ir_unop_i2u, r1051);
+ body.emit(assign(r103B, bit_or(r103B, r1052), 0x01));
+
+
+ body.instructions = f1040_parent_instructions;
+ body.emit(f1040);
+
+ /* END IF */
+
+ body.emit(assign(r1020, r103D, 0x01));
+
+ body.emit(assign(r1021, r103C, 0x01));
+
+ body.emit(assign(r1022, r103B, 0x01));
+
+ body.emit(assign(r101F, body.constant(0u), 0x01));
+
+ ir_expression *const r1053 = less(r103B, body.constant(0u));
+ ir_expression *const r1054 = expr(ir_unop_b2i, r1053);
+ body.emit(assign(r1025, expr(ir_unop_i2u, r1054), 0x01));
+
+
+ body.instructions = f1036_parent_instructions;
+ body.emit(f1036);
+
+ /* END IF */
+
+
+ body.instructions = f1033_parent_instructions;
+ body.emit(f1033);
+
+ /* END IF */
+
+
+ body.instructions = f1028_parent_instructions;
+ body.emit(f1028);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f1055 = new(mem_ctx) ir_if(operand(r1023).val);
+ exec_list *const f1055_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1055->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1057 = nequal(r1025, body.constant(0u));
+ ir_if *f1056 = new(mem_ctx) ir_if(operand(r1057).val);
+ exec_list *const f1056_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1056->then_instructions;
+
+ ir_variable *const r1058 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1058);
+ body.emit(assign(r1058, add(r1021, body.constant(1u)), 0x01));
+
+ ir_expression *const r1059 = less(r1058, r1021);
+ ir_expression *const r105A = expr(ir_unop_b2i, r1059);
+ ir_expression *const r105B = expr(ir_unop_i2u, r105A);
+ body.emit(assign(r1020, add(r1020, r105B), 0x01));
+
+ ir_expression *const r105C = neg(r1022);
+ ir_expression *const r105D = equal(r1022, r105C);
+ ir_expression *const r105E = expr(ir_unop_b2i, r105D);
+ ir_expression *const r105F = expr(ir_unop_i2u, r105E);
+ ir_expression *const r1060 = bit_and(r105F, body.constant(1u));
+ ir_expression *const r1061 = expr(ir_unop_bit_not, r1060);
+ body.emit(assign(r1021, bit_and(r1058, r1061), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1056->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1063 = bit_or(r1020, r1021);
+ ir_expression *const r1064 = equal(r1063, body.constant(0u));
+ ir_if *f1062 = new(mem_ctx) ir_if(operand(r1064).val);
+ exec_list *const f1062_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1062->then_instructions;
+
+ body.emit(assign(r101F, body.constant(0u), 0x01));
+
+
+ body.instructions = f1062_parent_instructions;
+ body.emit(f1062);
+
+ /* END IF */
+
+
+ body.instructions = f1056_parent_instructions;
+ body.emit(f1056);
+
+ /* END IF */
+
+ ir_variable *const r1065 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r1065);
+ ir_expression *const r1066 = lshift(r0EC9, body.constant(int(31)));
+ ir_expression *const r1067 = lshift(r101F, body.constant(int(20)));
+ ir_expression *const r1068 = add(r1066, r1067);
+ body.emit(assign(r1065, add(r1068, r1020), 0x01));
+
+ body.emit(assign(r1065, r1021, 0x02));
+
+ body.emit(assign(r1024, r1065, 0x03));
+
+ body.emit(assign(r1023, body.constant(false), 0x01));
+
+
+ body.instructions = f1055_parent_instructions;
+ body.emit(f1055);
+
+ /* END IF */
+
+ body.emit(assign(r0EC0, r1024, 0x03));
+
+ body.emit(assign(r0EBF, body.constant(false), 0x01));
+
+
+ body.instructions = f0FB6_parent_instructions;
+ body.emit(f0FB6);
+
+ /* END IF */
+
+
+ body.instructions = f0F6F_parent_instructions;
+ body.emit(f0F6F);
+
+ /* END IF */
+
+
+ body.instructions = f0F00_parent_instructions;
+ body.emit(f0F00);
+
+ /* END IF */
+
+
+ body.instructions = f0ED2_parent_instructions;
+ body.emit(f0ED2);
+
+ /* END IF */
+
+ body.emit(ret(r0EC0));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
diff --git a/src/compiler/glsl/builtin_functions.cpp b/src/compiler/glsl/builtin_functions.cpp
index 9b09147d27..43e622b74f 100644
--- a/src/compiler/glsl/builtin_functions.cpp
+++ b/src/compiler/glsl/builtin_functions.cpp
@@ -3153,6 +3153,10 @@ builtin_builder::create_builtins()
generate_ir::fadd64(mem_ctx, integer_functions_supported),
NULL);
+ add_function("__builtin_fmul64",
+ generate_ir::fmul64(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 8cab06aa1d..e141aa792a 100644
--- a/src/compiler/glsl/builtin_functions.h
+++ b/src/compiler/glsl/builtin_functions.h
@@ -81,6 +81,9 @@ flt64(void *mem_ctx, builtin_available_predicate avail);
ir_function_signature *
fadd64(void *mem_ctx, builtin_available_predicate avail);
+ir_function_signature *
+fmul64(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 ae9441f78a..372db0e94f 100644
--- a/src/compiler/glsl/float64.glsl
+++ b/src/compiler/glsl/float64.glsl
@@ -748,3 +748,175 @@ fadd64( uvec2 a, uvec2 b )
return subFloat64Fracs( a, b, aSign );
}
}
+
+/* Multiplies `a' by `b' to obtain a 64-bit product. The product is broken
+ * into two 32-bit pieces which are stored at the locations pointed to by
+ * `z0Ptr' and `z1Ptr'.
+ */
+void
+mul32To64( uint a, uint b, inout uint z0Ptr, inout uint z1Ptr )
+{
+ uint aHigh;
+ uint aLow;
+ uint bHigh;
+ uint bLow;
+ uint z0;
+ uint zMiddleA;
+ uint zMiddleB;
+ uint z1;
+
+ aLow = a;
+ aHigh = a>>16;
+ bLow = b;
+ bHigh = b>>16;
+ z1 = aLow * bLow;
+ zMiddleA = aLow * bHigh;
+ zMiddleB = aHigh * bLow;
+ z0 = aHigh * bHigh;
+ zMiddleA += zMiddleB;
+ z0 += ( ( uint ( zMiddleA < zMiddleB ) )<<16 ) + ( zMiddleA>>16 );
+ zMiddleA <<= 16;
+ z1 += zMiddleA;
+ z0 += uint ( z1 < zMiddleA );
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Multiplies the 64-bit value formed by concatenating `a0' and `a1' to the
+ * 64-bit value formed by concatenating `b0' and `b1' to obtain a 128-bit
+ * product. The product is broken into four 32-bit pieces which are stored at
+ * the locations pointed to by `z0Ptr', `z1Ptr', `z2Ptr', and `z3Ptr'.
+ */
+void
+mul64To128( uint a0, uint a1, uint b0, uint b1,
+ inout uint z0Ptr,
+ inout uint z1Ptr,
+ inout uint z2Ptr,
+ inout uint z3Ptr )
+{
+ uint z0 = 0u;
+ uint z1 = 0u;
+ uint z2 = 0u;
+ uint z3 = 0u;
+ uint more1 = 0u;
+ uint more2 = 0u;
+
+ mul32To64( a1, b1, z2, z3 );
+ mul32To64( a1, b0, z1, more2 );
+ add64( z1, more2, 0u, z2, z1, z2 );
+ mul32To64( a0, b0, z0, more1 );
+ add64( z0, more1, 0u, z1, z0, z1 );
+ mul32To64( a0, b1, more1, more2 );
+ add64( more1, more2, 0u, z2, more1, z2 );
+ add64( z0, z1, 0u, more1, z0, z1 );
+ z3Ptr = z3;
+ z2Ptr = z2;
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Normalizes the subnormal double-precision floating-point value represented
+ * by the denormalized significand formed by the concatenation of `aFrac0' and
+ * `aFrac1'. The normalized exponent is stored at the location pointed to by
+ * `zExpPtr'. The most significant 21 bits of the normalized significand are
+ * stored at the location pointed to by `zFrac0Ptr', and the least significant
+ * 32 bits of the normalized significand are stored at the location pointed to
+ * by `zFrac1Ptr'.
+ */
+void
+normalizeFloat64Subnormal( uint aFrac0, uint aFrac1,
+ inout uint zExpPtr,
+ inout uint zFrac0Ptr,
+ inout uint zFrac1Ptr )
+{
+ int shiftCount;
+
+ if ( aFrac0 == 0u ) {
+ shiftCount = int ( countLeadingZeros32( aFrac1 ) ) - 11;
+ if ( shiftCount < 0 ) {
+ zFrac0Ptr = aFrac1>>( - shiftCount );
+ zFrac1Ptr = aFrac1<<( shiftCount & 31 );
+ } else {
+ zFrac0Ptr = aFrac1<<shiftCount;
+ zFrac1Ptr = 0u;
+ }
+ zExpPtr = uint ( - shiftCount - 31 );
+ } else {
+ shiftCount = int ( countLeadingZeros32( aFrac0 ) ) - 11;
+ shortShift64Left( aFrac0, aFrac1, shiftCount, zFrac0Ptr, zFrac1Ptr );
+ zExpPtr = 1u - uint ( shiftCount );
+ }
+}
+
+/* Returns the result of multiplying the double-precision floating-point values
+ * `a' and `b'. The operation is performed according to the IEEE Standard for
+ * Floating-Point Arithmetic.
+ */
+uvec2
+fmul64( uvec2 a, uvec2 b )
+{
+ uint aSign;
+ uint bSign;
+ uint zSign;
+ uint aExp;
+ uint bExp;
+ uint zExp;
+ uvec2 aFrac;
+ uvec2 bFrac;
+ uint zFrac0 = 0u;
+ uint zFrac1 = 0u;
+ uint zFrac2 = 0u;
+ uint zFrac3 = 0u;
+
+ aFrac = extractFloat64Frac( a );
+ aExp = extractFloat64Exp( a );
+ aSign = extractFloat64Sign( a );
+ bFrac = extractFloat64Frac( b );
+ bExp = extractFloat64Exp( b );
+ bSign = extractFloat64Sign( b );
+ zSign = aSign ^ bSign;
+ if ( aExp == 0x7FFu ) {
+ if ( ( ( aFrac.x | aFrac.y ) != 0u ) ||
+ ( ( bExp == 0x7FFu ) && ( ( bFrac.x | bFrac.y ) != 0u ) ) ) {
+ return propagateFloat64NaN( a, b );
+ }
+ if ( ( bExp | bFrac.x | bFrac.y ) == 0u ) {
+ return uvec2(0xFFFFFFFFu, 0xFFFFFFFFu);
+ }
+ return packFloat64( zSign, 0x7FFu, 0u, 0u );
+ }
+ if ( bExp == 0x7FFu ) {
+ if ( ( bFrac.x | bFrac.y ) != 0u ) {
+ return propagateFloat64NaN( a, b );
+ }
+ if ( ( aExp | aFrac.x | aFrac.y ) == 0u ) {
+ return uvec2(0xFFFFFFFFu, 0xFFFFFFFFu);
+ }
+ return packFloat64( zSign, 0x7FFu, 0u, 0u );
+ }
+ if ( aExp == 0u ) {
+ if ( ( aFrac.x | aFrac.y ) == 0u ) {
+ return packFloat64( zSign, 0u, 0u, 0u );
+ }
+ normalizeFloat64Subnormal( aFrac.x, aFrac.y, aExp, aFrac.x, aFrac.y );
+ }
+ if ( bExp == 0u ) {
+ if ( ( bFrac.x | bFrac.y ) == 0u ) {
+ return packFloat64( zSign, 0u, 0u, 0u );
+ }
+ normalizeFloat64Subnormal( bFrac.x, bFrac.y, bExp, bFrac.x, bFrac.y );
+ }
+ zExp = uint ( int ( aExp + bExp ) - 0x400 );
+ aFrac.x |= 0x00100000u;
+ shortShift64Left( bFrac.x, bFrac.y, 12, bFrac.x, bFrac.y );
+ mul64To128(
+ aFrac.x, aFrac.y, bFrac.x, bFrac.y, zFrac0, zFrac1, zFrac2, zFrac3 );
+ add64( zFrac0, zFrac1, aFrac.x, aFrac.y, zFrac0, zFrac1 );
+ zFrac2 |= uint ( zFrac3 != 0u );
+ if ( 0x00200000u <= zFrac0 ) {
+ shift64ExtraRightJamming(
+ zFrac0, zFrac1, zFrac2, 1, zFrac0, zFrac1, zFrac2 );
+ ++zExp;
+ }
+ return roundAndPackFloat64( zSign, zExp, zFrac0, zFrac1, zFrac2 );
+}
--
2.11.0
More information about the mesa-dev
mailing list