[Mesa-dev] [RFC 08/11] glsl: Add "built-in" functions to do div(fp64, fp64)
Elie Tournier
tournier.elie at gmail.com
Fri Mar 3 16:23:04 UTC 2017
Signed-off-by: Elie Tournier <elie.tournier at collabora.com>
---
src/compiler/glsl/builtin_float64.h | 3153 +++++++++++++++++++++++++++++++
src/compiler/glsl/builtin_functions.cpp | 4 +
src/compiler/glsl/builtin_functions.h | 3 +
src/compiler/glsl/float64.glsl | 246 +++
4 files changed, 3406 insertions(+)
diff --git a/src/compiler/glsl/builtin_float64.h b/src/compiler/glsl/builtin_float64.h
index 0a363bd27a..a795d404c1 100644
--- a/src/compiler/glsl/builtin_float64.h
+++ b/src/compiler/glsl/builtin_float64.h
@@ -20009,3 +20009,3156 @@ r0F26_data.u[1] = 4294967295;
sig->replace_parameters(&sig_parameters);
return sig;
}
+ir_function_signature *
+add96(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 r1069 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r1069);
+ ir_variable *const r106A = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r106A);
+ ir_variable *const r106B = new(mem_ctx) ir_variable(glsl_type::uint_type, "a2", ir_var_function_in);
+ sig_parameters.push_tail(r106B);
+ ir_variable *const r106C = new(mem_ctx) ir_variable(glsl_type::uint_type, "b0", ir_var_function_in);
+ sig_parameters.push_tail(r106C);
+ ir_variable *const r106D = new(mem_ctx) ir_variable(glsl_type::uint_type, "b1", ir_var_function_in);
+ sig_parameters.push_tail(r106D);
+ ir_variable *const r106E = new(mem_ctx) ir_variable(glsl_type::uint_type, "b2", ir_var_function_in);
+ sig_parameters.push_tail(r106E);
+ ir_variable *const r106F = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r106F);
+ ir_variable *const r1070 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r1070);
+ ir_variable *const r1071 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r1071);
+ ir_variable *const r1072 = new(mem_ctx) ir_variable(glsl_type::uint_type, "carry1", ir_var_auto);
+ body.emit(r1072);
+ ir_variable *const r1073 = new(mem_ctx) ir_variable(glsl_type::uint_type, "carry0", ir_var_auto);
+ body.emit(r1073);
+ ir_variable *const r1074 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r1074);
+ ir_variable *const r1075 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1075);
+ ir_variable *const r1076 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1076);
+ body.emit(assign(r1074, add(r106B, r106E), 0x01));
+
+ ir_expression *const r1077 = less(r1074, r106B);
+ ir_expression *const r1078 = expr(ir_unop_b2i, r1077);
+ body.emit(assign(r1072, expr(ir_unop_i2u, r1078), 0x01));
+
+ body.emit(assign(r1075, add(r106A, r106D), 0x01));
+
+ ir_expression *const r1079 = less(r1075, r106A);
+ ir_expression *const r107A = expr(ir_unop_b2i, r1079);
+ body.emit(assign(r1073, expr(ir_unop_i2u, r107A), 0x01));
+
+ body.emit(assign(r1076, add(r1069, r106C), 0x01));
+
+ body.emit(assign(r1075, add(r1075, r1072), 0x01));
+
+ ir_expression *const r107B = less(r1075, r1072);
+ ir_expression *const r107C = expr(ir_unop_b2i, r107B);
+ ir_expression *const r107D = expr(ir_unop_i2u, r107C);
+ body.emit(assign(r1076, add(r1076, r107D), 0x01));
+
+ body.emit(assign(r1076, add(r1076, r1073), 0x01));
+
+ body.emit(assign(r1071, r1074, 0x01));
+
+ body.emit(assign(r1070, r1075, 0x01));
+
+ body.emit(assign(r106F, r1076, 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+sub96(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 r107E = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r107E);
+ ir_variable *const r107F = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r107F);
+ ir_variable *const r1080 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a2", ir_var_function_in);
+ sig_parameters.push_tail(r1080);
+ ir_variable *const r1081 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b0", ir_var_function_in);
+ sig_parameters.push_tail(r1081);
+ ir_variable *const r1082 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b1", ir_var_function_in);
+ sig_parameters.push_tail(r1082);
+ ir_variable *const r1083 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b2", ir_var_function_in);
+ sig_parameters.push_tail(r1083);
+ ir_variable *const r1084 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r1084);
+ ir_variable *const r1085 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r1085);
+ ir_variable *const r1086 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r1086);
+ ir_variable *const r1087 = new(mem_ctx) ir_variable(glsl_type::uint_type, "borrow1", ir_var_auto);
+ body.emit(r1087);
+ ir_variable *const r1088 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1088);
+ ir_variable *const r1089 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1089);
+ ir_expression *const r108A = less(r1080, r1083);
+ ir_expression *const r108B = expr(ir_unop_b2i, r108A);
+ body.emit(assign(r1087, expr(ir_unop_i2u, r108B), 0x01));
+
+ body.emit(assign(r1088, sub(r107F, r1082), 0x01));
+
+ body.emit(assign(r1089, sub(r107E, r1081), 0x01));
+
+ ir_expression *const r108C = less(r1088, r1087);
+ ir_expression *const r108D = expr(ir_unop_b2i, r108C);
+ ir_expression *const r108E = expr(ir_unop_i2u, r108D);
+ body.emit(assign(r1089, sub(r1089, r108E), 0x01));
+
+ body.emit(assign(r1088, sub(r1088, r1087), 0x01));
+
+ ir_expression *const r108F = less(r107F, r1082);
+ ir_expression *const r1090 = expr(ir_unop_b2i, r108F);
+ ir_expression *const r1091 = expr(ir_unop_i2u, r1090);
+ body.emit(assign(r1089, sub(r1089, r1091), 0x01));
+
+ body.emit(assign(r1086, sub(r1080, r1083), 0x01));
+
+ body.emit(assign(r1085, r1088, 0x01));
+
+ body.emit(assign(r1084, r1089, 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+shift64Right(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 r1092 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r1092);
+ ir_variable *const r1093 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r1093);
+ ir_variable *const r1094 = new(mem_ctx) ir_variable(glsl_type::int_type, "count", ir_var_function_in);
+ sig_parameters.push_tail(r1094);
+ ir_variable *const r1095 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r1095);
+ ir_variable *const r1096 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r1096);
+ ir_variable *const r1097 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1097);
+ ir_variable *const r1098 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1098);
+ ir_variable *const r1099 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r109A = neg(r1094);
+ body.emit(assign(r1099, bit_and(r109A, body.constant(int(31))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r109C = equal(r1094, body.constant(int(0)));
+ ir_if *f109B = new(mem_ctx) ir_if(operand(r109C).val);
+ exec_list *const f109B_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f109B->then_instructions;
+
+ body.emit(assign(r1097, r1093, 0x01));
+
+ body.emit(assign(r1098, r1092, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f109B->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r109E = less(r1094, body.constant(int(32)));
+ ir_if *f109D = new(mem_ctx) ir_if(operand(r109E).val);
+ exec_list *const f109D_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f109D->then_instructions;
+
+ ir_expression *const r109F = lshift(r1092, r1099);
+ ir_expression *const r10A0 = rshift(r1093, r1094);
+ body.emit(assign(r1097, bit_or(r109F, r10A0), 0x01));
+
+ body.emit(assign(r1098, rshift(r1092, r1094), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f109D->else_instructions;
+
+ ir_variable *const r10A1 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r10A3 = less(r1094, body.constant(int(64)));
+ ir_if *f10A2 = new(mem_ctx) ir_if(operand(r10A3).val);
+ exec_list *const f10A2_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f10A2->then_instructions;
+
+ ir_expression *const r10A4 = bit_and(r1094, body.constant(int(31)));
+ body.emit(assign(r10A1, rshift(r1092, r10A4), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f10A2->else_instructions;
+
+ body.emit(assign(r10A1, body.constant(0u), 0x01));
+
+
+ body.instructions = f10A2_parent_instructions;
+ body.emit(f10A2);
+
+ /* END IF */
+
+ body.emit(assign(r1097, r10A1, 0x01));
+
+ body.emit(assign(r1098, body.constant(0u), 0x01));
+
+
+ body.instructions = f109D_parent_instructions;
+ body.emit(f109D);
+
+ /* END IF */
+
+
+ body.instructions = f109B_parent_instructions;
+ body.emit(f109B);
+
+ /* END IF */
+
+ body.emit(assign(r1096, r1097, 0x01));
+
+ body.emit(assign(r1095, r1098, 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+estimateDiv64To32(void *mem_ctx, builtin_available_predicate avail)
+{
+ ir_function_signature *const sig =
+ new(mem_ctx) ir_function_signature(glsl_type::uint_type, avail);
+ ir_factory body(&sig->body, mem_ctx);
+ sig->is_defined = true;
+
+ exec_list sig_parameters;
+
+ ir_variable *const r10A5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r10A5);
+ ir_variable *const r10A6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r10A6);
+ ir_variable *const r10A7 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b", ir_var_function_in);
+ sig_parameters.push_tail(r10A7);
+ ir_variable *const r10A8 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r10A9 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z", ir_var_auto);
+ body.emit(r10A9);
+ ir_variable *const r10AA = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem1", ir_var_auto);
+ body.emit(r10AA);
+ ir_variable *const r10AB = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem0", ir_var_auto);
+ body.emit(r10AB);
+ ir_variable *const r10AC = new(mem_ctx) ir_variable(glsl_type::uint_type, "b0", ir_var_auto);
+ body.emit(r10AC);
+ body.emit(assign(r10AB, body.constant(0u), 0x01));
+
+ body.emit(assign(r10AA, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r10AE = lequal(r10A7, r10A5);
+ ir_if *f10AD = new(mem_ctx) ir_if(operand(r10AE).val);
+ exec_list *const f10AD_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f10AD->then_instructions;
+
+ body.emit(assign(r10A8, body.constant(4294967295u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f10AD->else_instructions;
+
+ body.emit(assign(r10AC, rshift(r10A7, body.constant(int(16))), 0x01));
+
+ ir_variable *const r10AF = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r10B1 = lshift(r10AC, body.constant(int(16)));
+ ir_expression *const r10B2 = lequal(r10B1, r10A5);
+ ir_if *f10B0 = new(mem_ctx) ir_if(operand(r10B2).val);
+ exec_list *const f10B0_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f10B0->then_instructions;
+
+ body.emit(assign(r10AF, body.constant(4294901760u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f10B0->else_instructions;
+
+ ir_expression *const r10B3 = expr(ir_binop_div, r10A5, r10AC);
+ body.emit(assign(r10AF, lshift(r10B3, body.constant(int(16))), 0x01));
+
+
+ body.instructions = f10B0_parent_instructions;
+ body.emit(f10B0);
+
+ /* END IF */
+
+ body.emit(assign(r10A9, r10AF, 0x01));
+
+ ir_variable *const r10B4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r10B4);
+ ir_variable *const r10B5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r10B5);
+ ir_variable *const r10B6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r10B6);
+ ir_variable *const r10B7 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r10B7);
+ ir_variable *const r10B8 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r10B8);
+ ir_variable *const r10B9 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r10B9);
+ body.emit(assign(r10B9, rshift(r10A7, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10B8, rshift(r10AF, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10B4, mul(r10A7, r10AF), 0x01));
+
+ body.emit(assign(r10B6, mul(r10A7, r10B8), 0x01));
+
+ body.emit(assign(r10B5, mul(r10B9, r10AF), 0x01));
+
+ body.emit(assign(r10B7, mul(r10B9, r10B8), 0x01));
+
+ body.emit(assign(r10B6, add(r10B6, r10B5), 0x01));
+
+ ir_expression *const r10BA = less(r10B6, r10B5);
+ ir_expression *const r10BB = expr(ir_unop_b2i, r10BA);
+ ir_expression *const r10BC = expr(ir_unop_i2u, r10BB);
+ ir_expression *const r10BD = lshift(r10BC, body.constant(int(16)));
+ ir_expression *const r10BE = rshift(r10B6, body.constant(int(16)));
+ ir_expression *const r10BF = add(r10BD, r10BE);
+ body.emit(assign(r10B7, add(r10B7, r10BF), 0x01));
+
+ body.emit(assign(r10B6, lshift(r10B6, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10B4, add(r10B4, r10B6), 0x01));
+
+ ir_expression *const r10C0 = less(r10B4, r10B6);
+ ir_expression *const r10C1 = expr(ir_unop_b2i, r10C0);
+ ir_expression *const r10C2 = expr(ir_unop_i2u, r10C1);
+ body.emit(assign(r10B7, add(r10B7, r10C2), 0x01));
+
+ ir_expression *const r10C3 = sub(r10A5, r10B7);
+ ir_expression *const r10C4 = less(r10A6, r10B4);
+ ir_expression *const r10C5 = expr(ir_unop_b2i, r10C4);
+ ir_expression *const r10C6 = expr(ir_unop_i2u, r10C5);
+ body.emit(assign(r10AB, sub(r10C3, r10C6), 0x01));
+
+ body.emit(assign(r10AA, sub(r10A6, r10B4), 0x01));
+
+ /* LOOP BEGIN */
+ ir_loop *f10C7 = new(mem_ctx) ir_loop();
+ exec_list *const f10C7_parent_instructions = body.instructions;
+
+ body.instructions = &f10C7->body_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r10C9 = gequal(r10AB, body.constant(0u));
+ ir_if *f10C8 = new(mem_ctx) ir_if(operand(r10C9).val);
+ exec_list *const f10C8_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f10C8->then_instructions;
+
+ body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
+
+
+ body.instructions = f10C8_parent_instructions;
+ body.emit(f10C8);
+
+ /* END IF */
+
+ body.emit(assign(r10A9, add(r10A9, body.constant(4294901760u)), 0x01));
+
+ ir_variable *const r10CA = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r10CA);
+ ir_expression *const r10CB = lshift(r10A7, body.constant(int(16)));
+ body.emit(assign(r10CA, add(r10AA, r10CB), 0x01));
+
+ ir_expression *const r10CC = add(r10AB, r10AC);
+ ir_expression *const r10CD = less(r10CA, r10AA);
+ ir_expression *const r10CE = expr(ir_unop_b2i, r10CD);
+ ir_expression *const r10CF = expr(ir_unop_i2u, r10CE);
+ body.emit(assign(r10AB, add(r10CC, r10CF), 0x01));
+
+ body.emit(assign(r10AA, r10CA, 0x01));
+
+ /* LOOP END */
+
+ body.instructions = f10C7_parent_instructions;
+ body.emit(f10C7);
+
+ ir_expression *const r10D0 = lshift(r10AB, body.constant(int(16)));
+ ir_expression *const r10D1 = rshift(r10AA, body.constant(int(16)));
+ body.emit(assign(r10AB, bit_or(r10D0, r10D1), 0x01));
+
+ ir_variable *const r10D2 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r10D4 = lshift(r10AC, body.constant(int(16)));
+ ir_expression *const r10D5 = lequal(r10D4, r10AB);
+ ir_if *f10D3 = new(mem_ctx) ir_if(operand(r10D5).val);
+ exec_list *const f10D3_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f10D3->then_instructions;
+
+ body.emit(assign(r10D2, body.constant(65535u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f10D3->else_instructions;
+
+ body.emit(assign(r10D2, expr(ir_binop_div, r10AB, r10AC), 0x01));
+
+
+ body.instructions = f10D3_parent_instructions;
+ body.emit(f10D3);
+
+ /* END IF */
+
+ body.emit(assign(r10A9, bit_or(r10A9, r10D2), 0x01));
+
+ body.emit(assign(r10A8, r10A9, 0x01));
+
+
+ body.instructions = f10AD_parent_instructions;
+ body.emit(f10AD);
+
+ /* END IF */
+
+ body.emit(ret(r10A8));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+mul64By32To96(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 r10D6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a0", ir_var_function_in);
+ sig_parameters.push_tail(r10D6);
+ ir_variable *const r10D7 = new(mem_ctx) ir_variable(glsl_type::uint_type, "a1", ir_var_function_in);
+ sig_parameters.push_tail(r10D7);
+ ir_variable *const r10D8 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b", ir_var_function_in);
+ sig_parameters.push_tail(r10D8);
+ ir_variable *const r10D9 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r10D9);
+ ir_variable *const r10DA = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r10DA);
+ ir_variable *const r10DB = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2Ptr", ir_var_function_inout);
+ sig_parameters.push_tail(r10DB);
+ ir_variable *const r10DC = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r10DC);
+ ir_variable *const r10DD = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r10DD);
+ ir_variable *const r10DE = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r10DE);
+ ir_variable *const r10DF = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r10DF);
+ ir_variable *const r10E0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r10E0);
+ ir_variable *const r10E1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r10E1);
+ body.emit(assign(r10E1, rshift(r10D7, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10E0, rshift(r10D8, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10DC, mul(r10D7, r10D8), 0x01));
+
+ body.emit(assign(r10DE, mul(r10D7, r10E0), 0x01));
+
+ body.emit(assign(r10DD, mul(r10E1, r10D8), 0x01));
+
+ body.emit(assign(r10DF, mul(r10E1, r10E0), 0x01));
+
+ body.emit(assign(r10DE, add(r10DE, r10DD), 0x01));
+
+ ir_expression *const r10E2 = less(r10DE, r10DD);
+ ir_expression *const r10E3 = expr(ir_unop_b2i, r10E2);
+ ir_expression *const r10E4 = expr(ir_unop_i2u, r10E3);
+ ir_expression *const r10E5 = lshift(r10E4, body.constant(int(16)));
+ ir_expression *const r10E6 = rshift(r10DE, body.constant(int(16)));
+ ir_expression *const r10E7 = add(r10E5, r10E6);
+ body.emit(assign(r10DF, add(r10DF, r10E7), 0x01));
+
+ body.emit(assign(r10DE, lshift(r10DE, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10DC, add(r10DC, r10DE), 0x01));
+
+ ir_expression *const r10E8 = less(r10DC, r10DE);
+ ir_expression *const r10E9 = expr(ir_unop_b2i, r10E8);
+ ir_expression *const r10EA = expr(ir_unop_i2u, r10E9);
+ body.emit(assign(r10DF, add(r10DF, r10EA), 0x01));
+
+ ir_variable *const r10EB = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r10EB);
+ ir_variable *const r10EC = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r10EC);
+ ir_variable *const r10ED = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r10ED);
+ ir_variable *const r10EE = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r10EE);
+ ir_variable *const r10EF = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r10EF);
+ ir_variable *const r10F0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r10F0);
+ body.emit(assign(r10F0, rshift(r10D6, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10EF, rshift(r10D8, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10EB, mul(r10D6, r10D8), 0x01));
+
+ body.emit(assign(r10ED, mul(r10D6, r10EF), 0x01));
+
+ body.emit(assign(r10EC, mul(r10F0, r10D8), 0x01));
+
+ body.emit(assign(r10EE, mul(r10F0, r10EF), 0x01));
+
+ body.emit(assign(r10ED, add(r10ED, r10EC), 0x01));
+
+ ir_expression *const r10F1 = less(r10ED, r10EC);
+ ir_expression *const r10F2 = expr(ir_unop_b2i, r10F1);
+ ir_expression *const r10F3 = expr(ir_unop_i2u, r10F2);
+ ir_expression *const r10F4 = lshift(r10F3, body.constant(int(16)));
+ ir_expression *const r10F5 = rshift(r10ED, body.constant(int(16)));
+ ir_expression *const r10F6 = add(r10F4, r10F5);
+ body.emit(assign(r10EE, add(r10EE, r10F6), 0x01));
+
+ body.emit(assign(r10ED, lshift(r10ED, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r10EB, add(r10EB, r10ED), 0x01));
+
+ ir_expression *const r10F7 = less(r10EB, r10ED);
+ ir_expression *const r10F8 = expr(ir_unop_b2i, r10F7);
+ ir_expression *const r10F9 = expr(ir_unop_i2u, r10F8);
+ body.emit(assign(r10EE, add(r10EE, r10F9), 0x01));
+
+ ir_variable *const r10FA = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r10FA);
+ body.emit(assign(r10FA, add(r10EB, r10DF), 0x01));
+
+ body.emit(assign(r10DB, r10DC, 0x01));
+
+ body.emit(assign(r10DA, r10FA, 0x01));
+
+ ir_expression *const r10FB = less(r10FA, r10EB);
+ ir_expression *const r10FC = expr(ir_unop_b2i, r10FB);
+ ir_expression *const r10FD = expr(ir_unop_i2u, r10FC);
+ body.emit(assign(r10D9, add(r10EE, r10FD), 0x01));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
+ir_function_signature *
+fdiv64(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 r10FE = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "a", ir_var_function_in);
+ sig_parameters.push_tail(r10FE);
+ ir_variable *const r10FF = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "b", ir_var_function_in);
+ sig_parameters.push_tail(r10FF);
+ ir_variable *const r1100 = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r1100, body.constant(true), 0x01));
+
+ ir_variable *const r1101 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r1102 = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem3", ir_var_auto);
+ body.emit(r1102);
+ ir_variable *const r1103 = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem2", ir_var_auto);
+ body.emit(r1103);
+ ir_variable *const r1104 = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem1", ir_var_auto);
+ body.emit(r1104);
+ ir_variable *const r1105 = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem0", ir_var_auto);
+ body.emit(r1105);
+ ir_variable *const r1106 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac1", ir_var_auto);
+ body.emit(r1106);
+ ir_variable *const r1107 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zFrac0", ir_var_auto);
+ body.emit(r1107);
+ ir_variable *const r1108 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "bFrac", ir_var_auto);
+ body.emit(r1108);
+ ir_variable *const r1109 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "aFrac", ir_var_auto);
+ body.emit(r1109);
+ ir_variable *const r110A = new(mem_ctx) ir_variable(glsl_type::uint_type, "zExp", ir_var_auto);
+ body.emit(r110A);
+ ir_variable *const r110B = new(mem_ctx) ir_variable(glsl_type::uint_type, "bExp", ir_var_auto);
+ body.emit(r110B);
+ ir_variable *const r110C = new(mem_ctx) ir_variable(glsl_type::uint_type, "aExp", ir_var_auto);
+ body.emit(r110C);
+ ir_variable *const r110D = new(mem_ctx) ir_variable(glsl_type::uint_type, "zSign", ir_var_auto);
+ body.emit(r110D);
+ body.emit(assign(r1107, body.constant(0u), 0x01));
+
+ body.emit(assign(r1106, body.constant(0u), 0x01));
+
+ body.emit(assign(r1105, body.constant(0u), 0x01));
+
+ body.emit(assign(r1104, body.constant(0u), 0x01));
+
+ body.emit(assign(r1103, body.constant(0u), 0x01));
+
+ body.emit(assign(r1102, body.constant(0u), 0x01));
+
+ ir_variable *const r110E = body.make_temp(glsl_type::uvec2_type, "vec_ctor");
+ body.emit(assign(r110E, bit_and(swizzle_x(r10FE), body.constant(1048575u)), 0x01));
+
+ body.emit(assign(r110E, swizzle_y(r10FE), 0x02));
+
+ body.emit(assign(r1109, r110E, 0x03));
+
+ ir_variable *const r110F = body.make_temp(glsl_type::uint_type, "extractFloat64Exp_retval");
+ ir_expression *const r1110 = rshift(swizzle_x(r10FE), body.constant(int(20)));
+ body.emit(assign(r110F, bit_and(r1110, body.constant(2047u)), 0x01));
+
+ body.emit(assign(r110C, r110F, 0x01));
+
+ ir_variable *const r1111 = body.make_temp(glsl_type::uvec2_type, "vec_ctor");
+ body.emit(assign(r1111, bit_and(swizzle_x(r10FF), body.constant(1048575u)), 0x01));
+
+ body.emit(assign(r1111, swizzle_y(r10FF), 0x02));
+
+ body.emit(assign(r1108, r1111, 0x03));
+
+ ir_variable *const r1112 = body.make_temp(glsl_type::uint_type, "extractFloat64Exp_retval");
+ ir_expression *const r1113 = rshift(swizzle_x(r10FF), body.constant(int(20)));
+ body.emit(assign(r1112, bit_and(r1113, body.constant(2047u)), 0x01));
+
+ body.emit(assign(r110B, r1112, 0x01));
+
+ ir_expression *const r1114 = rshift(swizzle_x(r10FE), body.constant(int(31)));
+ ir_expression *const r1115 = rshift(swizzle_x(r10FF), body.constant(int(31)));
+ body.emit(assign(r110D, bit_xor(r1114, r1115), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r1117 = equal(r110F, body.constant(2047u));
+ ir_if *f1116 = new(mem_ctx) ir_if(operand(r1117).val);
+ exec_list *const f1116_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1116->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1119 = bit_or(swizzle_x(r110E), swizzle_y(r10FE));
+ ir_expression *const r111A = nequal(r1119, body.constant(0u));
+ ir_if *f1118 = new(mem_ctx) ir_if(operand(r111A).val);
+ exec_list *const f1118_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1118->then_instructions;
+
+ ir_variable *const r111B = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r111B, swizzle_x(r10FE), 0x01));
+
+ ir_variable *const r111C = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r111C, swizzle_x(r10FF), 0x01));
+
+ ir_variable *const r111D = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r111E = body.make_temp(glsl_type::bool_type, "float64_is_signaling_nan_retval");
+ ir_expression *const r111F = rshift(swizzle_y(r10FE), body.constant(int(19)));
+ ir_expression *const r1120 = bit_and(r111F, body.constant(4095u));
+ ir_expression *const r1121 = equal(r1120, body.constant(4094u));
+ ir_expression *const r1122 = nequal(swizzle_x(r10FE), body.constant(0u));
+ ir_expression *const r1123 = bit_and(swizzle_y(r10FE), body.constant(524287u));
+ ir_expression *const r1124 = nequal(r1123, body.constant(0u));
+ ir_expression *const r1125 = logic_or(r1122, r1124);
+ body.emit(assign(r111E, logic_and(r1121, r1125), 0x01));
+
+ ir_variable *const r1126 = body.make_temp(glsl_type::bool_type, "float64_is_nan_retval");
+ ir_expression *const r1127 = lshift(swizzle_y(r10FF), body.constant(int(1)));
+ ir_expression *const r1128 = lequal(body.constant(4292870144u), r1127);
+ ir_expression *const r1129 = nequal(swizzle_x(r10FF), body.constant(0u));
+ ir_expression *const r112A = bit_and(swizzle_y(r10FF), body.constant(1048575u));
+ ir_expression *const r112B = nequal(r112A, body.constant(0u));
+ ir_expression *const r112C = logic_or(r1129, r112B);
+ body.emit(assign(r1126, logic_and(r1128, r112C), 0x01));
+
+ body.emit(assign(r111B, bit_or(swizzle_y(r10FE), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r111C, bit_or(swizzle_y(r10FF), body.constant(524288u)), 0x02));
+
+ /* IF CONDITION */
+ ir_expression *const r112E = lshift(swizzle_y(r10FE), body.constant(int(1)));
+ ir_expression *const r112F = lequal(body.constant(4292870144u), r112E);
+ ir_expression *const r1130 = nequal(swizzle_x(r10FE), body.constant(0u));
+ ir_expression *const r1131 = bit_and(swizzle_y(r10FE), body.constant(1048575u));
+ ir_expression *const r1132 = nequal(r1131, body.constant(0u));
+ ir_expression *const r1133 = logic_or(r1130, r1132);
+ ir_expression *const r1134 = logic_and(r112F, r1133);
+ ir_if *f112D = new(mem_ctx) ir_if(operand(r1134).val);
+ exec_list *const f112D_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f112D->then_instructions;
+
+ ir_variable *const r1135 = body.make_temp(glsl_type::uvec2_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r1137 = logic_and(r111E, r1126);
+ ir_if *f1136 = new(mem_ctx) ir_if(operand(r1137).val);
+ exec_list *const f1136_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1136->then_instructions;
+
+ body.emit(assign(r1135, r111C, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1136->else_instructions;
+
+ body.emit(assign(r1135, r111B, 0x03));
+
+
+ body.instructions = f1136_parent_instructions;
+ body.emit(f1136);
+
+ /* END IF */
+
+ body.emit(assign(r111D, r1135, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f112D->else_instructions;
+
+ body.emit(assign(r111D, r111C, 0x03));
+
+
+ body.instructions = f112D_parent_instructions;
+ body.emit(f112D);
+
+ /* END IF */
+
+ body.emit(assign(r1101, r111D, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1118->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1139 = equal(r1112, body.constant(2047u));
+ ir_if *f1138 = new(mem_ctx) ir_if(operand(r1139).val);
+ exec_list *const f1138_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1138->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r113B = bit_or(swizzle_x(r1111), swizzle_y(r10FF));
+ ir_expression *const r113C = nequal(r113B, body.constant(0u));
+ ir_if *f113A = new(mem_ctx) ir_if(operand(r113C).val);
+ exec_list *const f113A_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f113A->then_instructions;
+
+ ir_variable *const r113D = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r113D, swizzle_x(r10FE), 0x01));
+
+ ir_variable *const r113E = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r113E, swizzle_x(r10FF), 0x01));
+
+ ir_variable *const r113F = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r1140 = body.make_temp(glsl_type::bool_type, "float64_is_signaling_nan_retval");
+ ir_expression *const r1141 = rshift(swizzle_y(r10FE), body.constant(int(19)));
+ ir_expression *const r1142 = bit_and(r1141, body.constant(4095u));
+ ir_expression *const r1143 = equal(r1142, body.constant(4094u));
+ ir_expression *const r1144 = nequal(swizzle_x(r10FE), body.constant(0u));
+ ir_expression *const r1145 = bit_and(swizzle_y(r10FE), body.constant(524287u));
+ ir_expression *const r1146 = nequal(r1145, body.constant(0u));
+ ir_expression *const r1147 = logic_or(r1144, r1146);
+ body.emit(assign(r1140, logic_and(r1143, r1147), 0x01));
+
+ ir_variable *const r1148 = body.make_temp(glsl_type::bool_type, "float64_is_nan_retval");
+ ir_expression *const r1149 = lshift(swizzle_y(r10FF), body.constant(int(1)));
+ ir_expression *const r114A = lequal(body.constant(4292870144u), r1149);
+ ir_expression *const r114B = nequal(swizzle_x(r10FF), body.constant(0u));
+ ir_expression *const r114C = bit_and(swizzle_y(r10FF), body.constant(1048575u));
+ ir_expression *const r114D = nequal(r114C, body.constant(0u));
+ ir_expression *const r114E = logic_or(r114B, r114D);
+ body.emit(assign(r1148, logic_and(r114A, r114E), 0x01));
+
+ body.emit(assign(r113D, bit_or(swizzle_y(r10FE), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r113E, bit_or(swizzle_y(r10FF), body.constant(524288u)), 0x02));
+
+ /* IF CONDITION */
+ ir_expression *const r1150 = lshift(swizzle_y(r10FE), body.constant(int(1)));
+ ir_expression *const r1151 = lequal(body.constant(4292870144u), r1150);
+ ir_expression *const r1152 = nequal(swizzle_x(r10FE), body.constant(0u));
+ ir_expression *const r1153 = bit_and(swizzle_y(r10FE), body.constant(1048575u));
+ ir_expression *const r1154 = nequal(r1153, body.constant(0u));
+ ir_expression *const r1155 = logic_or(r1152, r1154);
+ ir_expression *const r1156 = logic_and(r1151, r1155);
+ ir_if *f114F = new(mem_ctx) ir_if(operand(r1156).val);
+ exec_list *const f114F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f114F->then_instructions;
+
+ ir_variable *const r1157 = body.make_temp(glsl_type::uvec2_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r1159 = logic_and(r1140, r1148);
+ ir_if *f1158 = new(mem_ctx) ir_if(operand(r1159).val);
+ exec_list *const f1158_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1158->then_instructions;
+
+ body.emit(assign(r1157, r113E, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1158->else_instructions;
+
+ body.emit(assign(r1157, r113D, 0x03));
+
+
+ body.instructions = f1158_parent_instructions;
+ body.emit(f1158);
+
+ /* END IF */
+
+ body.emit(assign(r113F, r1157, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f114F->else_instructions;
+
+ body.emit(assign(r113F, r113E, 0x03));
+
+
+ body.instructions = f114F_parent_instructions;
+ body.emit(f114F);
+
+ /* END IF */
+
+ body.emit(assign(r1101, r113F, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f113A->else_instructions;
+
+ ir_constant_data r115A_data;
+ memset(&r115A_data, 0, sizeof(ir_constant_data));
+r115A_data.u[0] = 4294967295;
+r115A_data.u[1] = 4294967295;
+ ir_constant *const r115A = new(mem_ctx) ir_constant(glsl_type::uvec2_type, &r115A_data);
+ body.emit(assign(r1101, r115A, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ body.instructions = f113A_parent_instructions;
+ body.emit(f113A);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1138->else_instructions;
+
+ ir_variable *const r115B = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r115B);
+ ir_expression *const r115C = lshift(r110D, body.constant(int(31)));
+ body.emit(assign(r115B, add(r115C, body.constant(2146435072u)), 0x01));
+
+ body.emit(assign(r115B, body.constant(0u), 0x02));
+
+ body.emit(assign(r1101, r115B, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ body.instructions = f1138_parent_instructions;
+ body.emit(f1138);
+
+ /* END IF */
+
+
+ body.instructions = f1118_parent_instructions;
+ body.emit(f1118);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1116->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r115E = equal(r1112, body.constant(2047u));
+ ir_if *f115D = new(mem_ctx) ir_if(operand(r115E).val);
+ exec_list *const f115D_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f115D->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1160 = bit_or(swizzle_x(r1111), swizzle_y(r10FF));
+ ir_expression *const r1161 = nequal(r1160, body.constant(0u));
+ ir_if *f115F = new(mem_ctx) ir_if(operand(r1161).val);
+ exec_list *const f115F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f115F->then_instructions;
+
+ ir_variable *const r1162 = body.make_temp(glsl_type::uvec2_type, "a");
+ body.emit(assign(r1162, swizzle_x(r10FE), 0x01));
+
+ ir_variable *const r1163 = body.make_temp(glsl_type::uvec2_type, "b");
+ body.emit(assign(r1163, swizzle_x(r10FF), 0x01));
+
+ ir_variable *const r1164 = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r1165 = body.make_temp(glsl_type::bool_type, "float64_is_signaling_nan_retval");
+ ir_expression *const r1166 = rshift(swizzle_y(r10FE), body.constant(int(19)));
+ ir_expression *const r1167 = bit_and(r1166, body.constant(4095u));
+ ir_expression *const r1168 = equal(r1167, body.constant(4094u));
+ ir_expression *const r1169 = nequal(swizzle_x(r10FE), body.constant(0u));
+ ir_expression *const r116A = bit_and(swizzle_y(r10FE), body.constant(524287u));
+ ir_expression *const r116B = nequal(r116A, body.constant(0u));
+ ir_expression *const r116C = logic_or(r1169, r116B);
+ body.emit(assign(r1165, logic_and(r1168, r116C), 0x01));
+
+ ir_variable *const r116D = body.make_temp(glsl_type::bool_type, "float64_is_nan_retval");
+ ir_expression *const r116E = lshift(swizzle_y(r10FF), body.constant(int(1)));
+ ir_expression *const r116F = lequal(body.constant(4292870144u), r116E);
+ ir_expression *const r1170 = nequal(swizzle_x(r10FF), body.constant(0u));
+ ir_expression *const r1171 = bit_and(swizzle_y(r10FF), body.constant(1048575u));
+ ir_expression *const r1172 = nequal(r1171, body.constant(0u));
+ ir_expression *const r1173 = logic_or(r1170, r1172);
+ body.emit(assign(r116D, logic_and(r116F, r1173), 0x01));
+
+ body.emit(assign(r1162, bit_or(swizzle_y(r10FE), body.constant(524288u)), 0x02));
+
+ body.emit(assign(r1163, bit_or(swizzle_y(r10FF), body.constant(524288u)), 0x02));
+
+ /* IF CONDITION */
+ ir_expression *const r1175 = lshift(swizzle_y(r10FE), body.constant(int(1)));
+ ir_expression *const r1176 = lequal(body.constant(4292870144u), r1175);
+ ir_expression *const r1177 = nequal(swizzle_x(r10FE), body.constant(0u));
+ ir_expression *const r1178 = bit_and(swizzle_y(r10FE), body.constant(1048575u));
+ ir_expression *const r1179 = nequal(r1178, body.constant(0u));
+ ir_expression *const r117A = logic_or(r1177, r1179);
+ ir_expression *const r117B = logic_and(r1176, r117A);
+ ir_if *f1174 = new(mem_ctx) ir_if(operand(r117B).val);
+ exec_list *const f1174_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1174->then_instructions;
+
+ ir_variable *const r117C = body.make_temp(glsl_type::uvec2_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r117E = logic_and(r1165, r116D);
+ ir_if *f117D = new(mem_ctx) ir_if(operand(r117E).val);
+ exec_list *const f117D_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f117D->then_instructions;
+
+ body.emit(assign(r117C, r1163, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f117D->else_instructions;
+
+ body.emit(assign(r117C, r1162, 0x03));
+
+
+ body.instructions = f117D_parent_instructions;
+ body.emit(f117D);
+
+ /* END IF */
+
+ body.emit(assign(r1164, r117C, 0x03));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1174->else_instructions;
+
+ body.emit(assign(r1164, r1163, 0x03));
+
+
+ body.instructions = f1174_parent_instructions;
+ body.emit(f1174);
+
+ /* END IF */
+
+ body.emit(assign(r1101, r1164, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f115F->else_instructions;
+
+ ir_variable *const r117F = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r117F);
+ body.emit(assign(r117F, lshift(r110D, body.constant(int(31))), 0x01));
+
+ body.emit(assign(r117F, body.constant(0u), 0x02));
+
+ body.emit(assign(r1101, r117F, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ body.instructions = f115F_parent_instructions;
+ body.emit(f115F);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f115D->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1181 = equal(r1112, body.constant(0u));
+ ir_if *f1180 = new(mem_ctx) ir_if(operand(r1181).val);
+ exec_list *const f1180_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1180->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1183 = bit_or(swizzle_x(r1111), swizzle_y(r10FF));
+ ir_expression *const r1184 = equal(r1183, body.constant(0u));
+ ir_if *f1182 = new(mem_ctx) ir_if(operand(r1184).val);
+ exec_list *const f1182_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1182->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1186 = bit_or(r110F, swizzle_x(r110E));
+ ir_expression *const r1187 = bit_or(r1186, swizzle_y(r10FE));
+ ir_expression *const r1188 = equal(r1187, body.constant(0u));
+ ir_if *f1185 = new(mem_ctx) ir_if(operand(r1188).val);
+ exec_list *const f1185_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1185->then_instructions;
+
+ ir_constant_data r1189_data;
+ memset(&r1189_data, 0, sizeof(ir_constant_data));
+r1189_data.u[0] = 4294967295;
+r1189_data.u[1] = 4294967295;
+ ir_constant *const r1189 = new(mem_ctx) ir_constant(glsl_type::uvec2_type, &r1189_data);
+ body.emit(assign(r1101, r1189, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1185->else_instructions;
+
+ ir_variable *const r118A = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r118A);
+ ir_expression *const r118B = lshift(r110D, body.constant(int(31)));
+ body.emit(assign(r118A, add(r118B, body.constant(2146435072u)), 0x01));
+
+ body.emit(assign(r118A, body.constant(0u), 0x02));
+
+ body.emit(assign(r1101, r118A, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ body.instructions = f1185_parent_instructions;
+ body.emit(f1185);
+
+ /* END IF */
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1182->else_instructions;
+
+ ir_variable *const r118C = body.make_temp(glsl_type::uint_type, "aFrac0");
+ body.emit(assign(r118C, swizzle_x(r1111), 0x01));
+
+ ir_variable *const r118D = body.make_temp(glsl_type::uint_type, "aFrac1");
+ body.emit(assign(r118D, swizzle_y(r1111), 0x01));
+
+ ir_variable *const r118E = body.make_temp(glsl_type::uint_type, "zExpPtr");
+ body.emit(assign(r118E, r1112, 0x01));
+
+ ir_variable *const r118F = body.make_temp(glsl_type::uint_type, "zFrac0Ptr");
+ body.emit(assign(r118F, swizzle_x(r1111), 0x01));
+
+ ir_variable *const r1190 = body.make_temp(glsl_type::uint_type, "zFrac1Ptr");
+ body.emit(assign(r1190, swizzle_y(r1111), 0x01));
+
+ ir_variable *const r1191 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r1191);
+ /* IF CONDITION */
+ ir_expression *const r1193 = equal(swizzle_x(r1111), body.constant(0u));
+ ir_if *f1192 = new(mem_ctx) ir_if(operand(r1193).val);
+ exec_list *const f1192_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1192->then_instructions;
+
+ ir_variable *const r1194 = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r1194, r118D, 0x01));
+
+ ir_variable *const r1195 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r1196 = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r1196);
+ /* IF CONDITION */
+ ir_expression *const r1198 = equal(swizzle_y(r10FF), body.constant(0u));
+ ir_if *f1197 = new(mem_ctx) ir_if(operand(r1198).val);
+ exec_list *const f1197_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1197->then_instructions;
+
+ body.emit(assign(r1195, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1197->else_instructions;
+
+ body.emit(assign(r1196, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r119A = bit_and(swizzle_y(r10FF), body.constant(4294901760u));
+ ir_expression *const r119B = equal(r119A, body.constant(0u));
+ ir_if *f1199 = new(mem_ctx) ir_if(operand(r119B).val);
+ exec_list *const f1199_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1199->then_instructions;
+
+ body.emit(assign(r1196, body.constant(16u), 0x01));
+
+ body.emit(assign(r1194, lshift(swizzle_y(r10FF), body.constant(int(16))), 0x01));
+
+
+ body.instructions = f1199_parent_instructions;
+ body.emit(f1199);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r119D = bit_and(r1194, body.constant(4278190080u));
+ ir_expression *const r119E = equal(r119D, body.constant(0u));
+ ir_if *f119C = new(mem_ctx) ir_if(operand(r119E).val);
+ exec_list *const f119C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f119C->then_instructions;
+
+ body.emit(assign(r1196, add(r1196, body.constant(8u)), 0x01));
+
+ body.emit(assign(r1194, lshift(r1194, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f119C_parent_instructions;
+ body.emit(f119C);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11A0 = bit_and(r1194, body.constant(4026531840u));
+ ir_expression *const r11A1 = equal(r11A0, body.constant(0u));
+ ir_if *f119F = new(mem_ctx) ir_if(operand(r11A1).val);
+ exec_list *const f119F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f119F->then_instructions;
+
+ body.emit(assign(r1196, add(r1196, body.constant(4u)), 0x01));
+
+ body.emit(assign(r1194, lshift(r1194, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f119F_parent_instructions;
+ body.emit(f119F);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11A3 = bit_and(r1194, body.constant(3221225472u));
+ ir_expression *const r11A4 = equal(r11A3, body.constant(0u));
+ ir_if *f11A2 = new(mem_ctx) ir_if(operand(r11A4).val);
+ exec_list *const f11A2_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11A2->then_instructions;
+
+ body.emit(assign(r1196, add(r1196, body.constant(2u)), 0x01));
+
+ body.emit(assign(r1194, lshift(r1194, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f11A2_parent_instructions;
+ body.emit(f11A2);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11A6 = bit_and(r1194, body.constant(2147483648u));
+ ir_expression *const r11A7 = equal(r11A6, body.constant(0u));
+ ir_if *f11A5 = new(mem_ctx) ir_if(operand(r11A7).val);
+ exec_list *const f11A5_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11A5->then_instructions;
+
+ body.emit(assign(r1196, add(r1196, body.constant(1u)), 0x01));
+
+
+ body.instructions = f11A5_parent_instructions;
+ body.emit(f11A5);
+
+ /* END IF */
+
+ body.emit(assign(r1195, r1196, 0x01));
+
+
+ body.instructions = f1197_parent_instructions;
+ body.emit(f1197);
+
+ /* END IF */
+
+ ir_expression *const r11A8 = expr(ir_unop_u2i, r1195);
+ body.emit(assign(r1191, add(r11A8, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r11AA = less(r1191, body.constant(int(0)));
+ ir_if *f11A9 = new(mem_ctx) ir_if(operand(r11AA).val);
+ exec_list *const f11A9_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11A9->then_instructions;
+
+ ir_expression *const r11AB = neg(r1191);
+ body.emit(assign(r118F, rshift(swizzle_y(r10FF), r11AB), 0x01));
+
+ ir_expression *const r11AC = bit_and(r1191, body.constant(int(31)));
+ body.emit(assign(r1190, lshift(swizzle_y(r10FF), r11AC), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f11A9->else_instructions;
+
+ body.emit(assign(r118F, lshift(swizzle_y(r10FF), r1191), 0x01));
+
+ body.emit(assign(r1190, body.constant(0u), 0x01));
+
+
+ body.instructions = f11A9_parent_instructions;
+ body.emit(f11A9);
+
+ /* END IF */
+
+ ir_expression *const r11AD = sub(body.constant(int(-31)), r1191);
+ body.emit(assign(r118E, expr(ir_unop_i2u, r11AD), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1192->else_instructions;
+
+ ir_variable *const r11AE = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r11AE, r118C, 0x01));
+
+ ir_variable *const r11AF = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r11B0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r11B0);
+ /* IF CONDITION */
+ ir_expression *const r11B2 = equal(swizzle_x(r1111), body.constant(0u));
+ ir_if *f11B1 = new(mem_ctx) ir_if(operand(r11B2).val);
+ exec_list *const f11B1_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11B1->then_instructions;
+
+ body.emit(assign(r11AF, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f11B1->else_instructions;
+
+ body.emit(assign(r11B0, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r11B4 = bit_and(swizzle_x(r1111), body.constant(4294901760u));
+ ir_expression *const r11B5 = equal(r11B4, body.constant(0u));
+ ir_if *f11B3 = new(mem_ctx) ir_if(operand(r11B5).val);
+ exec_list *const f11B3_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11B3->then_instructions;
+
+ body.emit(assign(r11B0, body.constant(16u), 0x01));
+
+ body.emit(assign(r11AE, lshift(swizzle_x(r1111), body.constant(int(16))), 0x01));
+
+
+ body.instructions = f11B3_parent_instructions;
+ body.emit(f11B3);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11B7 = bit_and(r11AE, body.constant(4278190080u));
+ ir_expression *const r11B8 = equal(r11B7, body.constant(0u));
+ ir_if *f11B6 = new(mem_ctx) ir_if(operand(r11B8).val);
+ exec_list *const f11B6_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11B6->then_instructions;
+
+ body.emit(assign(r11B0, add(r11B0, body.constant(8u)), 0x01));
+
+ body.emit(assign(r11AE, lshift(r11AE, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f11B6_parent_instructions;
+ body.emit(f11B6);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11BA = bit_and(r11AE, body.constant(4026531840u));
+ ir_expression *const r11BB = equal(r11BA, body.constant(0u));
+ ir_if *f11B9 = new(mem_ctx) ir_if(operand(r11BB).val);
+ exec_list *const f11B9_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11B9->then_instructions;
+
+ body.emit(assign(r11B0, add(r11B0, body.constant(4u)), 0x01));
+
+ body.emit(assign(r11AE, lshift(r11AE, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f11B9_parent_instructions;
+ body.emit(f11B9);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11BD = bit_and(r11AE, body.constant(3221225472u));
+ ir_expression *const r11BE = equal(r11BD, body.constant(0u));
+ ir_if *f11BC = new(mem_ctx) ir_if(operand(r11BE).val);
+ exec_list *const f11BC_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11BC->then_instructions;
+
+ body.emit(assign(r11B0, add(r11B0, body.constant(2u)), 0x01));
+
+ body.emit(assign(r11AE, lshift(r11AE, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f11BC_parent_instructions;
+ body.emit(f11BC);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11C0 = bit_and(r11AE, body.constant(2147483648u));
+ ir_expression *const r11C1 = equal(r11C0, body.constant(0u));
+ ir_if *f11BF = new(mem_ctx) ir_if(operand(r11C1).val);
+ exec_list *const f11BF_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11BF->then_instructions;
+
+ body.emit(assign(r11B0, add(r11B0, body.constant(1u)), 0x01));
+
+
+ body.instructions = f11BF_parent_instructions;
+ body.emit(f11BF);
+
+ /* END IF */
+
+ body.emit(assign(r11AF, r11B0, 0x01));
+
+
+ body.instructions = f11B1_parent_instructions;
+ body.emit(f11B1);
+
+ /* END IF */
+
+ ir_expression *const r11C2 = expr(ir_unop_u2i, r11AF);
+ body.emit(assign(r1191, add(r11C2, body.constant(int(-11))), 0x01));
+
+ ir_variable *const r11C3 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r11C3, lshift(swizzle_y(r10FF), r1191), 0x01));
+
+ ir_variable *const r11C4 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r11C6 = equal(r1191, body.constant(int(0)));
+ ir_if *f11C5 = new(mem_ctx) ir_if(operand(r11C6).val);
+ exec_list *const f11C5_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11C5->then_instructions;
+
+ body.emit(assign(r11C4, r118C, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f11C5->else_instructions;
+
+ ir_expression *const r11C7 = lshift(swizzle_x(r1111), r1191);
+ ir_expression *const r11C8 = neg(r1191);
+ ir_expression *const r11C9 = bit_and(r11C8, body.constant(int(31)));
+ ir_expression *const r11CA = rshift(swizzle_y(r10FF), r11C9);
+ body.emit(assign(r11C4, bit_or(r11C7, r11CA), 0x01));
+
+
+ body.instructions = f11C5_parent_instructions;
+ body.emit(f11C5);
+
+ /* END IF */
+
+ body.emit(assign(r118F, r11C4, 0x01));
+
+ body.emit(assign(r1190, r11C3, 0x01));
+
+ ir_expression *const r11CB = expr(ir_unop_i2u, r1191);
+ body.emit(assign(r118E, sub(body.constant(1u), r11CB), 0x01));
+
+
+ body.instructions = f1192_parent_instructions;
+ body.emit(f1192);
+
+ /* END IF */
+
+ body.emit(assign(r110B, r118E, 0x01));
+
+ body.emit(assign(r1108, r118F, 0x01));
+
+ body.emit(assign(r1108, r1190, 0x02));
+
+
+ body.instructions = f1182_parent_instructions;
+ body.emit(f1182);
+
+ /* END IF */
+
+
+ body.instructions = f1180_parent_instructions;
+ body.emit(f1180);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f11CC = new(mem_ctx) ir_if(operand(r1100).val);
+ exec_list *const f11CC_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11CC->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r11CE = equal(r110F, body.constant(0u));
+ ir_if *f11CD = new(mem_ctx) ir_if(operand(r11CE).val);
+ exec_list *const f11CD_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11CD->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r11D0 = bit_or(swizzle_x(r110E), swizzle_y(r10FE));
+ ir_expression *const r11D1 = equal(r11D0, body.constant(0u));
+ ir_if *f11CF = new(mem_ctx) ir_if(operand(r11D1).val);
+ exec_list *const f11CF_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11CF->then_instructions;
+
+ ir_variable *const r11D2 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r11D2);
+ body.emit(assign(r11D2, lshift(r110D, body.constant(int(31))), 0x01));
+
+ body.emit(assign(r11D2, body.constant(0u), 0x02));
+
+ body.emit(assign(r1101, r11D2, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f11CF->else_instructions;
+
+ ir_variable *const r11D3 = body.make_temp(glsl_type::uint_type, "aFrac0");
+ body.emit(assign(r11D3, swizzle_x(r110E), 0x01));
+
+ ir_variable *const r11D4 = body.make_temp(glsl_type::uint_type, "aFrac1");
+ body.emit(assign(r11D4, swizzle_y(r110E), 0x01));
+
+ ir_variable *const r11D5 = body.make_temp(glsl_type::uint_type, "zExpPtr");
+ body.emit(assign(r11D5, r110F, 0x01));
+
+ ir_variable *const r11D6 = body.make_temp(glsl_type::uint_type, "zFrac0Ptr");
+ body.emit(assign(r11D6, swizzle_x(r110E), 0x01));
+
+ ir_variable *const r11D7 = body.make_temp(glsl_type::uint_type, "zFrac1Ptr");
+ body.emit(assign(r11D7, swizzle_y(r110E), 0x01));
+
+ ir_variable *const r11D8 = new(mem_ctx) ir_variable(glsl_type::int_type, "shiftCount", ir_var_auto);
+ body.emit(r11D8);
+ /* IF CONDITION */
+ ir_expression *const r11DA = equal(swizzle_x(r110E), body.constant(0u));
+ ir_if *f11D9 = new(mem_ctx) ir_if(operand(r11DA).val);
+ exec_list *const f11D9_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11D9->then_instructions;
+
+ ir_variable *const r11DB = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r11DB, r11D4, 0x01));
+
+ ir_variable *const r11DC = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r11DD = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r11DD);
+ /* IF CONDITION */
+ ir_expression *const r11DF = equal(swizzle_y(r10FE), body.constant(0u));
+ ir_if *f11DE = new(mem_ctx) ir_if(operand(r11DF).val);
+ exec_list *const f11DE_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11DE->then_instructions;
+
+ body.emit(assign(r11DC, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f11DE->else_instructions;
+
+ body.emit(assign(r11DD, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r11E1 = bit_and(swizzle_y(r10FE), body.constant(4294901760u));
+ ir_expression *const r11E2 = equal(r11E1, body.constant(0u));
+ ir_if *f11E0 = new(mem_ctx) ir_if(operand(r11E2).val);
+ exec_list *const f11E0_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11E0->then_instructions;
+
+ body.emit(assign(r11DD, body.constant(16u), 0x01));
+
+ body.emit(assign(r11DB, lshift(swizzle_y(r10FE), body.constant(int(16))), 0x01));
+
+
+ body.instructions = f11E0_parent_instructions;
+ body.emit(f11E0);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11E4 = bit_and(r11DB, body.constant(4278190080u));
+ ir_expression *const r11E5 = equal(r11E4, body.constant(0u));
+ ir_if *f11E3 = new(mem_ctx) ir_if(operand(r11E5).val);
+ exec_list *const f11E3_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11E3->then_instructions;
+
+ body.emit(assign(r11DD, add(r11DD, body.constant(8u)), 0x01));
+
+ body.emit(assign(r11DB, lshift(r11DB, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f11E3_parent_instructions;
+ body.emit(f11E3);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11E7 = bit_and(r11DB, body.constant(4026531840u));
+ ir_expression *const r11E8 = equal(r11E7, body.constant(0u));
+ ir_if *f11E6 = new(mem_ctx) ir_if(operand(r11E8).val);
+ exec_list *const f11E6_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11E6->then_instructions;
+
+ body.emit(assign(r11DD, add(r11DD, body.constant(4u)), 0x01));
+
+ body.emit(assign(r11DB, lshift(r11DB, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f11E6_parent_instructions;
+ body.emit(f11E6);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11EA = bit_and(r11DB, body.constant(3221225472u));
+ ir_expression *const r11EB = equal(r11EA, body.constant(0u));
+ ir_if *f11E9 = new(mem_ctx) ir_if(operand(r11EB).val);
+ exec_list *const f11E9_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11E9->then_instructions;
+
+ body.emit(assign(r11DD, add(r11DD, body.constant(2u)), 0x01));
+
+ body.emit(assign(r11DB, lshift(r11DB, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f11E9_parent_instructions;
+ body.emit(f11E9);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11ED = bit_and(r11DB, body.constant(2147483648u));
+ ir_expression *const r11EE = equal(r11ED, body.constant(0u));
+ ir_if *f11EC = new(mem_ctx) ir_if(operand(r11EE).val);
+ exec_list *const f11EC_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11EC->then_instructions;
+
+ body.emit(assign(r11DD, add(r11DD, body.constant(1u)), 0x01));
+
+
+ body.instructions = f11EC_parent_instructions;
+ body.emit(f11EC);
+
+ /* END IF */
+
+ body.emit(assign(r11DC, r11DD, 0x01));
+
+
+ body.instructions = f11DE_parent_instructions;
+ body.emit(f11DE);
+
+ /* END IF */
+
+ ir_expression *const r11EF = expr(ir_unop_u2i, r11DC);
+ body.emit(assign(r11D8, add(r11EF, body.constant(int(-11))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r11F1 = less(r11D8, body.constant(int(0)));
+ ir_if *f11F0 = new(mem_ctx) ir_if(operand(r11F1).val);
+ exec_list *const f11F0_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11F0->then_instructions;
+
+ ir_expression *const r11F2 = neg(r11D8);
+ body.emit(assign(r11D6, rshift(swizzle_y(r10FE), r11F2), 0x01));
+
+ ir_expression *const r11F3 = bit_and(r11D8, body.constant(int(31)));
+ body.emit(assign(r11D7, lshift(swizzle_y(r10FE), r11F3), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f11F0->else_instructions;
+
+ body.emit(assign(r11D6, lshift(swizzle_y(r10FE), r11D8), 0x01));
+
+ body.emit(assign(r11D7, body.constant(0u), 0x01));
+
+
+ body.instructions = f11F0_parent_instructions;
+ body.emit(f11F0);
+
+ /* END IF */
+
+ ir_expression *const r11F4 = sub(body.constant(int(-31)), r11D8);
+ body.emit(assign(r11D5, expr(ir_unop_i2u, r11F4), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f11D9->else_instructions;
+
+ ir_variable *const r11F5 = body.make_temp(glsl_type::uint_type, "a");
+ body.emit(assign(r11F5, r11D3, 0x01));
+
+ ir_variable *const r11F6 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r11F7 = new(mem_ctx) ir_variable(glsl_type::uint_type, "shiftCount", ir_var_auto);
+ body.emit(r11F7);
+ /* IF CONDITION */
+ ir_expression *const r11F9 = equal(swizzle_x(r110E), body.constant(0u));
+ ir_if *f11F8 = new(mem_ctx) ir_if(operand(r11F9).val);
+ exec_list *const f11F8_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11F8->then_instructions;
+
+ body.emit(assign(r11F6, body.constant(32u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f11F8->else_instructions;
+
+ body.emit(assign(r11F7, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r11FB = bit_and(swizzle_x(r110E), body.constant(4294901760u));
+ ir_expression *const r11FC = equal(r11FB, body.constant(0u));
+ ir_if *f11FA = new(mem_ctx) ir_if(operand(r11FC).val);
+ exec_list *const f11FA_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11FA->then_instructions;
+
+ body.emit(assign(r11F7, body.constant(16u), 0x01));
+
+ body.emit(assign(r11F5, lshift(swizzle_x(r110E), body.constant(int(16))), 0x01));
+
+
+ body.instructions = f11FA_parent_instructions;
+ body.emit(f11FA);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r11FE = bit_and(r11F5, body.constant(4278190080u));
+ ir_expression *const r11FF = equal(r11FE, body.constant(0u));
+ ir_if *f11FD = new(mem_ctx) ir_if(operand(r11FF).val);
+ exec_list *const f11FD_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f11FD->then_instructions;
+
+ body.emit(assign(r11F7, add(r11F7, body.constant(8u)), 0x01));
+
+ body.emit(assign(r11F5, lshift(r11F5, body.constant(int(8))), 0x01));
+
+
+ body.instructions = f11FD_parent_instructions;
+ body.emit(f11FD);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r1201 = bit_and(r11F5, body.constant(4026531840u));
+ ir_expression *const r1202 = equal(r1201, body.constant(0u));
+ ir_if *f1200 = new(mem_ctx) ir_if(operand(r1202).val);
+ exec_list *const f1200_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1200->then_instructions;
+
+ body.emit(assign(r11F7, add(r11F7, body.constant(4u)), 0x01));
+
+ body.emit(assign(r11F5, lshift(r11F5, body.constant(int(4))), 0x01));
+
+
+ body.instructions = f1200_parent_instructions;
+ body.emit(f1200);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r1204 = bit_and(r11F5, body.constant(3221225472u));
+ ir_expression *const r1205 = equal(r1204, body.constant(0u));
+ ir_if *f1203 = new(mem_ctx) ir_if(operand(r1205).val);
+ exec_list *const f1203_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1203->then_instructions;
+
+ body.emit(assign(r11F7, add(r11F7, body.constant(2u)), 0x01));
+
+ body.emit(assign(r11F5, lshift(r11F5, body.constant(int(2))), 0x01));
+
+
+ body.instructions = f1203_parent_instructions;
+ body.emit(f1203);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_expression *const r1207 = bit_and(r11F5, body.constant(2147483648u));
+ ir_expression *const r1208 = equal(r1207, body.constant(0u));
+ ir_if *f1206 = new(mem_ctx) ir_if(operand(r1208).val);
+ exec_list *const f1206_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1206->then_instructions;
+
+ body.emit(assign(r11F7, add(r11F7, body.constant(1u)), 0x01));
+
+
+ body.instructions = f1206_parent_instructions;
+ body.emit(f1206);
+
+ /* END IF */
+
+ body.emit(assign(r11F6, r11F7, 0x01));
+
+
+ body.instructions = f11F8_parent_instructions;
+ body.emit(f11F8);
+
+ /* END IF */
+
+ ir_expression *const r1209 = expr(ir_unop_u2i, r11F6);
+ body.emit(assign(r11D8, add(r1209, body.constant(int(-11))), 0x01));
+
+ ir_variable *const r120A = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r120A, lshift(swizzle_y(r10FE), r11D8), 0x01));
+
+ ir_variable *const r120B = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r120D = equal(r11D8, body.constant(int(0)));
+ ir_if *f120C = new(mem_ctx) ir_if(operand(r120D).val);
+ exec_list *const f120C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f120C->then_instructions;
+
+ body.emit(assign(r120B, r11D3, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f120C->else_instructions;
+
+ ir_expression *const r120E = lshift(swizzle_x(r110E), r11D8);
+ ir_expression *const r120F = neg(r11D8);
+ ir_expression *const r1210 = bit_and(r120F, body.constant(int(31)));
+ ir_expression *const r1211 = rshift(swizzle_y(r10FE), r1210);
+ body.emit(assign(r120B, bit_or(r120E, r1211), 0x01));
+
+
+ body.instructions = f120C_parent_instructions;
+ body.emit(f120C);
+
+ /* END IF */
+
+ body.emit(assign(r11D6, r120B, 0x01));
+
+ body.emit(assign(r11D7, r120A, 0x01));
+
+ ir_expression *const r1212 = expr(ir_unop_i2u, r11D8);
+ body.emit(assign(r11D5, sub(body.constant(1u), r1212), 0x01));
+
+
+ body.instructions = f11D9_parent_instructions;
+ body.emit(f11D9);
+
+ /* END IF */
+
+ body.emit(assign(r110C, r11D5, 0x01));
+
+ body.emit(assign(r1109, r11D6, 0x01));
+
+ body.emit(assign(r1109, r11D7, 0x02));
+
+
+ body.instructions = f11CF_parent_instructions;
+ body.emit(f11CF);
+
+ /* END IF */
+
+
+ body.instructions = f11CD_parent_instructions;
+ body.emit(f11CD);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f1213 = new(mem_ctx) ir_if(operand(r1100).val);
+ exec_list *const f1213_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1213->then_instructions;
+
+ ir_expression *const r1214 = sub(r110C, r110B);
+ body.emit(assign(r110A, add(r1214, body.constant(1021u)), 0x01));
+
+ ir_variable *const r1215 = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r1215, lshift(swizzle_y(r1109), body.constant(int(11))), 0x01));
+
+ ir_variable *const r1216 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ ir_expression *const r1217 = bit_or(swizzle_x(r1109), body.constant(1048576u));
+ ir_expression *const r1218 = lshift(r1217, body.constant(int(11)));
+ ir_expression *const r1219 = rshift(swizzle_y(r1109), body.constant(int(21)));
+ body.emit(assign(r1216, bit_or(r1218, r1219), 0x01));
+
+ body.emit(assign(r1109, r1216, 0x01));
+
+ body.emit(assign(r1109, r1215, 0x02));
+
+ ir_variable *const r121A = body.make_temp(glsl_type::uint_type, "z1Ptr");
+ body.emit(assign(r121A, lshift(swizzle_y(r1108), body.constant(int(11))), 0x01));
+
+ ir_variable *const r121B = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ ir_expression *const r121C = bit_or(swizzle_x(r1108), body.constant(1048576u));
+ ir_expression *const r121D = lshift(r121C, body.constant(int(11)));
+ ir_expression *const r121E = rshift(swizzle_y(r1108), body.constant(int(21)));
+ body.emit(assign(r121B, bit_or(r121D, r121E), 0x01));
+
+ body.emit(assign(r1108, r121B, 0x01));
+
+ body.emit(assign(r1108, r121A, 0x02));
+
+ /* IF CONDITION */
+ ir_expression *const r1220 = less(r121B, r1216);
+ ir_expression *const r1221 = equal(r121B, r1216);
+ ir_expression *const r1222 = lequal(r121A, r1215);
+ ir_expression *const r1223 = logic_and(r1221, r1222);
+ ir_expression *const r1224 = logic_or(r1220, r1223);
+ ir_if *f121F = new(mem_ctx) ir_if(operand(r1224).val);
+ exec_list *const f121F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f121F->then_instructions;
+
+ body.emit(assign(r1109, rshift(r1216, body.constant(int(1))), 0x01));
+
+ ir_expression *const r1225 = lshift(r1216, body.constant(int(31)));
+ ir_expression *const r1226 = rshift(r1215, body.constant(int(1)));
+ body.emit(assign(r1109, bit_or(r1225, r1226), 0x02));
+
+ body.emit(assign(r110A, add(r110A, body.constant(1u)), 0x01));
+
+
+ body.instructions = f121F_parent_instructions;
+ body.emit(f121F);
+
+ /* END IF */
+
+ ir_variable *const r1227 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r1228 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z", ir_var_auto);
+ body.emit(r1228);
+ ir_variable *const r1229 = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem1", ir_var_auto);
+ body.emit(r1229);
+ ir_variable *const r122A = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem0", ir_var_auto);
+ body.emit(r122A);
+ ir_variable *const r122B = new(mem_ctx) ir_variable(glsl_type::uint_type, "b0", ir_var_auto);
+ body.emit(r122B);
+ body.emit(assign(r122A, body.constant(0u), 0x01));
+
+ body.emit(assign(r1229, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r122D = lequal(r121B, swizzle_x(r1109));
+ ir_if *f122C = new(mem_ctx) ir_if(operand(r122D).val);
+ exec_list *const f122C_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f122C->then_instructions;
+
+ body.emit(assign(r1227, body.constant(4294967295u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f122C->else_instructions;
+
+ body.emit(assign(r122B, rshift(r121B, body.constant(int(16))), 0x01));
+
+ ir_variable *const r122E = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r1230 = lshift(r122B, body.constant(int(16)));
+ ir_expression *const r1231 = lequal(r1230, swizzle_x(r1109));
+ ir_if *f122F = new(mem_ctx) ir_if(operand(r1231).val);
+ exec_list *const f122F_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f122F->then_instructions;
+
+ body.emit(assign(r122E, body.constant(4294901760u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f122F->else_instructions;
+
+ ir_expression *const r1232 = expr(ir_binop_div, swizzle_x(r1109), r122B);
+ body.emit(assign(r122E, lshift(r1232, body.constant(int(16))), 0x01));
+
+
+ body.instructions = f122F_parent_instructions;
+ body.emit(f122F);
+
+ /* END IF */
+
+ body.emit(assign(r1228, r122E, 0x01));
+
+ ir_variable *const r1233 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1233);
+ ir_variable *const r1234 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r1234);
+ ir_variable *const r1235 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r1235);
+ ir_variable *const r1236 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1236);
+ ir_variable *const r1237 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r1237);
+ ir_variable *const r1238 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r1238);
+ body.emit(assign(r1238, rshift(r121B, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1237, rshift(r122E, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1233, mul(r121B, r122E), 0x01));
+
+ body.emit(assign(r1235, mul(r121B, r1237), 0x01));
+
+ body.emit(assign(r1234, mul(r1238, r122E), 0x01));
+
+ body.emit(assign(r1236, mul(r1238, r1237), 0x01));
+
+ body.emit(assign(r1235, add(r1235, r1234), 0x01));
+
+ ir_expression *const r1239 = less(r1235, r1234);
+ ir_expression *const r123A = expr(ir_unop_b2i, r1239);
+ ir_expression *const r123B = expr(ir_unop_i2u, r123A);
+ ir_expression *const r123C = lshift(r123B, body.constant(int(16)));
+ ir_expression *const r123D = rshift(r1235, body.constant(int(16)));
+ ir_expression *const r123E = add(r123C, r123D);
+ body.emit(assign(r1236, add(r1236, r123E), 0x01));
+
+ body.emit(assign(r1235, lshift(r1235, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1233, add(r1233, r1235), 0x01));
+
+ ir_expression *const r123F = less(r1233, r1235);
+ ir_expression *const r1240 = expr(ir_unop_b2i, r123F);
+ ir_expression *const r1241 = expr(ir_unop_i2u, r1240);
+ body.emit(assign(r1236, add(r1236, r1241), 0x01));
+
+ ir_expression *const r1242 = sub(swizzle_x(r1109), r1236);
+ ir_expression *const r1243 = less(swizzle_y(r1109), r1233);
+ ir_expression *const r1244 = expr(ir_unop_b2i, r1243);
+ ir_expression *const r1245 = expr(ir_unop_i2u, r1244);
+ body.emit(assign(r122A, sub(r1242, r1245), 0x01));
+
+ body.emit(assign(r1229, sub(swizzle_y(r1109), r1233), 0x01));
+
+ /* LOOP BEGIN */
+ ir_loop *f1246 = new(mem_ctx) ir_loop();
+ exec_list *const f1246_parent_instructions = body.instructions;
+
+ body.instructions = &f1246->body_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1248 = gequal(r122A, body.constant(0u));
+ ir_if *f1247 = new(mem_ctx) ir_if(operand(r1248).val);
+ exec_list *const f1247_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1247->then_instructions;
+
+ body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
+
+
+ body.instructions = f1247_parent_instructions;
+ body.emit(f1247);
+
+ /* END IF */
+
+ body.emit(assign(r1228, add(r1228, body.constant(4294901760u)), 0x01));
+
+ ir_variable *const r1249 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1249);
+ ir_expression *const r124A = lshift(r121B, body.constant(int(16)));
+ body.emit(assign(r1249, add(r1229, r124A), 0x01));
+
+ ir_expression *const r124B = add(r122A, r122B);
+ ir_expression *const r124C = less(r1249, r1229);
+ ir_expression *const r124D = expr(ir_unop_b2i, r124C);
+ ir_expression *const r124E = expr(ir_unop_i2u, r124D);
+ body.emit(assign(r122A, add(r124B, r124E), 0x01));
+
+ body.emit(assign(r1229, r1249, 0x01));
+
+ /* LOOP END */
+
+ body.instructions = f1246_parent_instructions;
+ body.emit(f1246);
+
+ ir_expression *const r124F = lshift(r122A, body.constant(int(16)));
+ ir_expression *const r1250 = rshift(r1229, body.constant(int(16)));
+ body.emit(assign(r122A, bit_or(r124F, r1250), 0x01));
+
+ ir_variable *const r1251 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r1253 = lshift(r122B, body.constant(int(16)));
+ ir_expression *const r1254 = lequal(r1253, r122A);
+ ir_if *f1252 = new(mem_ctx) ir_if(operand(r1254).val);
+ exec_list *const f1252_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1252->then_instructions;
+
+ body.emit(assign(r1251, body.constant(65535u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1252->else_instructions;
+
+ body.emit(assign(r1251, expr(ir_binop_div, r122A, r122B), 0x01));
+
+
+ body.instructions = f1252_parent_instructions;
+ body.emit(f1252);
+
+ /* END IF */
+
+ body.emit(assign(r1228, bit_or(r1228, r1251), 0x01));
+
+ body.emit(assign(r1227, r1228, 0x01));
+
+
+ body.instructions = f122C_parent_instructions;
+ body.emit(f122C);
+
+ /* END IF */
+
+ body.emit(assign(r1107, r1227, 0x01));
+
+ ir_variable *const r1255 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1255);
+ ir_variable *const r1256 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r1256);
+ ir_variable *const r1257 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r1257);
+ ir_variable *const r1258 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1258);
+ ir_variable *const r1259 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r1259);
+ ir_variable *const r125A = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r125A);
+ body.emit(assign(r125A, rshift(r121A, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1259, rshift(r1227, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1255, mul(r121A, r1227), 0x01));
+
+ body.emit(assign(r1257, mul(r121A, r1259), 0x01));
+
+ body.emit(assign(r1256, mul(r125A, r1227), 0x01));
+
+ body.emit(assign(r1258, mul(r125A, r1259), 0x01));
+
+ body.emit(assign(r1257, add(r1257, r1256), 0x01));
+
+ ir_expression *const r125B = less(r1257, r1256);
+ ir_expression *const r125C = expr(ir_unop_b2i, r125B);
+ ir_expression *const r125D = expr(ir_unop_i2u, r125C);
+ ir_expression *const r125E = lshift(r125D, body.constant(int(16)));
+ ir_expression *const r125F = rshift(r1257, body.constant(int(16)));
+ ir_expression *const r1260 = add(r125E, r125F);
+ body.emit(assign(r1258, add(r1258, r1260), 0x01));
+
+ body.emit(assign(r1257, lshift(r1257, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1255, add(r1255, r1257), 0x01));
+
+ ir_expression *const r1261 = less(r1255, r1257);
+ ir_expression *const r1262 = expr(ir_unop_b2i, r1261);
+ ir_expression *const r1263 = expr(ir_unop_i2u, r1262);
+ body.emit(assign(r1258, add(r1258, r1263), 0x01));
+
+ ir_variable *const r1264 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1264);
+ ir_variable *const r1265 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r1265);
+ ir_variable *const r1266 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r1266);
+ ir_variable *const r1267 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1267);
+ ir_variable *const r1268 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r1268);
+ ir_variable *const r1269 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r1269);
+ body.emit(assign(r1269, rshift(r121B, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1268, rshift(r1227, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1264, mul(r121B, r1227), 0x01));
+
+ body.emit(assign(r1266, mul(r121B, r1268), 0x01));
+
+ body.emit(assign(r1265, mul(r1269, r1227), 0x01));
+
+ body.emit(assign(r1267, mul(r1269, r1268), 0x01));
+
+ body.emit(assign(r1266, add(r1266, r1265), 0x01));
+
+ ir_expression *const r126A = less(r1266, r1265);
+ ir_expression *const r126B = expr(ir_unop_b2i, r126A);
+ ir_expression *const r126C = expr(ir_unop_i2u, r126B);
+ ir_expression *const r126D = lshift(r126C, body.constant(int(16)));
+ ir_expression *const r126E = rshift(r1266, body.constant(int(16)));
+ ir_expression *const r126F = add(r126D, r126E);
+ body.emit(assign(r1267, add(r1267, r126F), 0x01));
+
+ body.emit(assign(r1266, lshift(r1266, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r1264, add(r1264, r1266), 0x01));
+
+ ir_expression *const r1270 = less(r1264, r1266);
+ ir_expression *const r1271 = expr(ir_unop_b2i, r1270);
+ ir_expression *const r1272 = expr(ir_unop_i2u, r1271);
+ body.emit(assign(r1267, add(r1267, r1272), 0x01));
+
+ ir_variable *const r1273 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1273);
+ body.emit(assign(r1273, add(r1264, r1258), 0x01));
+
+ ir_variable *const r1274 = new(mem_ctx) ir_variable(glsl_type::uint_type, "borrow1", ir_var_auto);
+ body.emit(r1274);
+ ir_variable *const r1275 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1275);
+ ir_variable *const r1276 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1276);
+ ir_expression *const r1277 = less(body.constant(0u), r1255);
+ ir_expression *const r1278 = expr(ir_unop_b2i, r1277);
+ body.emit(assign(r1274, expr(ir_unop_i2u, r1278), 0x01));
+
+ body.emit(assign(r1275, sub(swizzle_y(r1109), r1273), 0x01));
+
+ ir_expression *const r1279 = less(r1273, r1264);
+ ir_expression *const r127A = expr(ir_unop_b2i, r1279);
+ ir_expression *const r127B = expr(ir_unop_i2u, r127A);
+ ir_expression *const r127C = add(r1267, r127B);
+ body.emit(assign(r1276, sub(swizzle_x(r1109), r127C), 0x01));
+
+ ir_expression *const r127D = less(r1275, r1274);
+ ir_expression *const r127E = expr(ir_unop_b2i, r127D);
+ ir_expression *const r127F = expr(ir_unop_i2u, r127E);
+ body.emit(assign(r1276, sub(r1276, r127F), 0x01));
+
+ body.emit(assign(r1275, sub(r1275, r1274), 0x01));
+
+ ir_expression *const r1280 = less(swizzle_y(r1109), r1273);
+ ir_expression *const r1281 = expr(ir_unop_b2i, r1280);
+ ir_expression *const r1282 = expr(ir_unop_i2u, r1281);
+ body.emit(assign(r1276, sub(r1276, r1282), 0x01));
+
+ body.emit(assign(r1105, r1276, 0x01));
+
+ body.emit(assign(r1104, r1275, 0x01));
+
+ body.emit(assign(r1103, neg(r1255), 0x01));
+
+ /* LOOP BEGIN */
+ ir_loop *f1283 = new(mem_ctx) ir_loop();
+ exec_list *const f1283_parent_instructions = body.instructions;
+
+ body.instructions = &f1283->body_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1285 = gequal(r1105, body.constant(0u));
+ ir_if *f1284 = new(mem_ctx) ir_if(operand(r1285).val);
+ exec_list *const f1284_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1284->then_instructions;
+
+ body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
+
+
+ body.instructions = f1284_parent_instructions;
+ body.emit(f1284);
+
+ /* END IF */
+
+ body.emit(assign(r1107, add(r1107, body.constant(4294967295u)), 0x01));
+
+ ir_variable *const r1286 = new(mem_ctx) ir_variable(glsl_type::uint_type, "carry1", ir_var_auto);
+ body.emit(r1286);
+ ir_variable *const r1287 = new(mem_ctx) ir_variable(glsl_type::uint_type, "carry0", ir_var_auto);
+ body.emit(r1287);
+ ir_variable *const r1288 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r1288);
+ ir_variable *const r1289 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1289);
+ ir_variable *const r128A = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r128A);
+ body.emit(assign(r1288, add(r1103, r121A), 0x01));
+
+ ir_expression *const r128B = less(r1288, r1103);
+ ir_expression *const r128C = expr(ir_unop_b2i, r128B);
+ body.emit(assign(r1286, expr(ir_unop_i2u, r128C), 0x01));
+
+ body.emit(assign(r1289, add(r1104, r121B), 0x01));
+
+ ir_expression *const r128D = less(r1289, r1104);
+ ir_expression *const r128E = expr(ir_unop_b2i, r128D);
+ body.emit(assign(r1287, expr(ir_unop_i2u, r128E), 0x01));
+
+ body.emit(assign(r1289, add(r1289, r1286), 0x01));
+
+ ir_expression *const r128F = less(r1289, r1286);
+ ir_expression *const r1290 = expr(ir_unop_b2i, r128F);
+ ir_expression *const r1291 = expr(ir_unop_i2u, r1290);
+ body.emit(assign(r128A, add(r1105, r1291), 0x01));
+
+ body.emit(assign(r128A, add(r128A, r1287), 0x01));
+
+ body.emit(assign(r1105, r128A, 0x01));
+
+ body.emit(assign(r1104, r1289, 0x01));
+
+ body.emit(assign(r1103, r1288, 0x01));
+
+ /* LOOP END */
+
+ body.instructions = f1283_parent_instructions;
+ body.emit(f1283);
+
+ ir_variable *const r1292 = body.make_temp(glsl_type::uint_type, "return_value");
+ ir_variable *const r1293 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z", ir_var_auto);
+ body.emit(r1293);
+ ir_variable *const r1294 = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem1", ir_var_auto);
+ body.emit(r1294);
+ ir_variable *const r1295 = new(mem_ctx) ir_variable(glsl_type::uint_type, "rem0", ir_var_auto);
+ body.emit(r1295);
+ ir_variable *const r1296 = new(mem_ctx) ir_variable(glsl_type::uint_type, "b0", ir_var_auto);
+ body.emit(r1296);
+ body.emit(assign(r1295, body.constant(0u), 0x01));
+
+ body.emit(assign(r1294, body.constant(0u), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r1298 = lequal(r121B, r1104);
+ ir_if *f1297 = new(mem_ctx) ir_if(operand(r1298).val);
+ exec_list *const f1297_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1297->then_instructions;
+
+ body.emit(assign(r1292, body.constant(4294967295u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1297->else_instructions;
+
+ body.emit(assign(r1296, rshift(r121B, body.constant(int(16))), 0x01));
+
+ ir_variable *const r1299 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r129B = lshift(r1296, body.constant(int(16)));
+ ir_expression *const r129C = lequal(r129B, r1104);
+ ir_if *f129A = new(mem_ctx) ir_if(operand(r129C).val);
+ exec_list *const f129A_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f129A->then_instructions;
+
+ body.emit(assign(r1299, body.constant(4294901760u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f129A->else_instructions;
+
+ ir_expression *const r129D = expr(ir_binop_div, r1104, r1296);
+ body.emit(assign(r1299, lshift(r129D, body.constant(int(16))), 0x01));
+
+
+ body.instructions = f129A_parent_instructions;
+ body.emit(f129A);
+
+ /* END IF */
+
+ body.emit(assign(r1293, r1299, 0x01));
+
+ ir_variable *const r129E = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r129E);
+ ir_variable *const r129F = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r129F);
+ ir_variable *const r12A0 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r12A0);
+ ir_variable *const r12A1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r12A1);
+ ir_variable *const r12A2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r12A2);
+ ir_variable *const r12A3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r12A3);
+ body.emit(assign(r12A3, rshift(r121B, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r12A2, rshift(r1299, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r129E, mul(r121B, r1299), 0x01));
+
+ body.emit(assign(r12A0, mul(r121B, r12A2), 0x01));
+
+ body.emit(assign(r129F, mul(r12A3, r1299), 0x01));
+
+ body.emit(assign(r12A1, mul(r12A3, r12A2), 0x01));
+
+ body.emit(assign(r12A0, add(r12A0, r129F), 0x01));
+
+ ir_expression *const r12A4 = less(r12A0, r129F);
+ ir_expression *const r12A5 = expr(ir_unop_b2i, r12A4);
+ ir_expression *const r12A6 = expr(ir_unop_i2u, r12A5);
+ ir_expression *const r12A7 = lshift(r12A6, body.constant(int(16)));
+ ir_expression *const r12A8 = rshift(r12A0, body.constant(int(16)));
+ ir_expression *const r12A9 = add(r12A7, r12A8);
+ body.emit(assign(r12A1, add(r12A1, r12A9), 0x01));
+
+ body.emit(assign(r12A0, lshift(r12A0, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r129E, add(r129E, r12A0), 0x01));
+
+ ir_expression *const r12AA = less(r129E, r12A0);
+ ir_expression *const r12AB = expr(ir_unop_b2i, r12AA);
+ ir_expression *const r12AC = expr(ir_unop_i2u, r12AB);
+ body.emit(assign(r12A1, add(r12A1, r12AC), 0x01));
+
+ ir_expression *const r12AD = sub(r1104, r12A1);
+ ir_expression *const r12AE = less(r1103, r129E);
+ ir_expression *const r12AF = expr(ir_unop_b2i, r12AE);
+ ir_expression *const r12B0 = expr(ir_unop_i2u, r12AF);
+ body.emit(assign(r1295, sub(r12AD, r12B0), 0x01));
+
+ body.emit(assign(r1294, sub(r1103, r129E), 0x01));
+
+ /* LOOP BEGIN */
+ ir_loop *f12B1 = new(mem_ctx) ir_loop();
+ exec_list *const f12B1_parent_instructions = body.instructions;
+
+ body.instructions = &f12B1->body_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r12B3 = gequal(r1295, body.constant(0u));
+ ir_if *f12B2 = new(mem_ctx) ir_if(operand(r12B3).val);
+ exec_list *const f12B2_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f12B2->then_instructions;
+
+ body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
+
+
+ body.instructions = f12B2_parent_instructions;
+ body.emit(f12B2);
+
+ /* END IF */
+
+ body.emit(assign(r1293, add(r1293, body.constant(4294901760u)), 0x01));
+
+ ir_variable *const r12B4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r12B4);
+ ir_expression *const r12B5 = lshift(r121B, body.constant(int(16)));
+ body.emit(assign(r12B4, add(r1294, r12B5), 0x01));
+
+ ir_expression *const r12B6 = add(r1295, r1296);
+ ir_expression *const r12B7 = less(r12B4, r1294);
+ ir_expression *const r12B8 = expr(ir_unop_b2i, r12B7);
+ ir_expression *const r12B9 = expr(ir_unop_i2u, r12B8);
+ body.emit(assign(r1295, add(r12B6, r12B9), 0x01));
+
+ body.emit(assign(r1294, r12B4, 0x01));
+
+ /* LOOP END */
+
+ body.instructions = f12B1_parent_instructions;
+ body.emit(f12B1);
+
+ ir_expression *const r12BA = lshift(r1295, body.constant(int(16)));
+ ir_expression *const r12BB = rshift(r1294, body.constant(int(16)));
+ body.emit(assign(r1295, bit_or(r12BA, r12BB), 0x01));
+
+ ir_variable *const r12BC = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r12BE = lshift(r1296, body.constant(int(16)));
+ ir_expression *const r12BF = lequal(r12BE, r1295);
+ ir_if *f12BD = new(mem_ctx) ir_if(operand(r12BF).val);
+ exec_list *const f12BD_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f12BD->then_instructions;
+
+ body.emit(assign(r12BC, body.constant(65535u), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f12BD->else_instructions;
+
+ body.emit(assign(r12BC, expr(ir_binop_div, r1295, r1296), 0x01));
+
+
+ body.instructions = f12BD_parent_instructions;
+ body.emit(f12BD);
+
+ /* END IF */
+
+ body.emit(assign(r1293, bit_or(r1293, r12BC), 0x01));
+
+ body.emit(assign(r1292, r1293, 0x01));
+
+
+ body.instructions = f1297_parent_instructions;
+ body.emit(f1297);
+
+ /* END IF */
+
+ body.emit(assign(r1106, r1292, 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r12C1 = bit_and(r1292, body.constant(1023u));
+ ir_expression *const r12C2 = lequal(r12C1, body.constant(4u));
+ ir_if *f12C0 = new(mem_ctx) ir_if(operand(r12C2).val);
+ exec_list *const f12C0_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f12C0->then_instructions;
+
+ ir_variable *const r12C3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r12C3);
+ ir_variable *const r12C4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r12C4);
+ ir_variable *const r12C5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r12C5);
+ ir_variable *const r12C6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r12C6);
+ ir_variable *const r12C7 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r12C7);
+ ir_variable *const r12C8 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r12C8);
+ body.emit(assign(r12C8, rshift(r121A, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r12C7, rshift(r1292, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r12C3, mul(r121A, r1292), 0x01));
+
+ body.emit(assign(r12C5, mul(r121A, r12C7), 0x01));
+
+ body.emit(assign(r12C4, mul(r12C8, r1292), 0x01));
+
+ body.emit(assign(r12C6, mul(r12C8, r12C7), 0x01));
+
+ body.emit(assign(r12C5, add(r12C5, r12C4), 0x01));
+
+ ir_expression *const r12C9 = less(r12C5, r12C4);
+ ir_expression *const r12CA = expr(ir_unop_b2i, r12C9);
+ ir_expression *const r12CB = expr(ir_unop_i2u, r12CA);
+ ir_expression *const r12CC = lshift(r12CB, body.constant(int(16)));
+ ir_expression *const r12CD = rshift(r12C5, body.constant(int(16)));
+ ir_expression *const r12CE = add(r12CC, r12CD);
+ body.emit(assign(r12C6, add(r12C6, r12CE), 0x01));
+
+ body.emit(assign(r12C5, lshift(r12C5, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r12C3, add(r12C3, r12C5), 0x01));
+
+ ir_expression *const r12CF = less(r12C3, r12C5);
+ ir_expression *const r12D0 = expr(ir_unop_b2i, r12CF);
+ ir_expression *const r12D1 = expr(ir_unop_i2u, r12D0);
+ body.emit(assign(r12C6, add(r12C6, r12D1), 0x01));
+
+ ir_variable *const r12D2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r12D2);
+ ir_variable *const r12D3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleB", ir_var_auto);
+ body.emit(r12D3);
+ ir_variable *const r12D4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "zMiddleA", ir_var_auto);
+ body.emit(r12D4);
+ ir_variable *const r12D5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r12D5);
+ ir_variable *const r12D6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "bHigh", ir_var_auto);
+ body.emit(r12D6);
+ ir_variable *const r12D7 = new(mem_ctx) ir_variable(glsl_type::uint_type, "aHigh", ir_var_auto);
+ body.emit(r12D7);
+ body.emit(assign(r12D7, rshift(r121B, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r12D6, rshift(r1292, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r12D2, mul(r121B, r1292), 0x01));
+
+ body.emit(assign(r12D4, mul(r121B, r12D6), 0x01));
+
+ body.emit(assign(r12D3, mul(r12D7, r1292), 0x01));
+
+ body.emit(assign(r12D5, mul(r12D7, r12D6), 0x01));
+
+ body.emit(assign(r12D4, add(r12D4, r12D3), 0x01));
+
+ ir_expression *const r12D8 = less(r12D4, r12D3);
+ ir_expression *const r12D9 = expr(ir_unop_b2i, r12D8);
+ ir_expression *const r12DA = expr(ir_unop_i2u, r12D9);
+ ir_expression *const r12DB = lshift(r12DA, body.constant(int(16)));
+ ir_expression *const r12DC = rshift(r12D4, body.constant(int(16)));
+ ir_expression *const r12DD = add(r12DB, r12DC);
+ body.emit(assign(r12D5, add(r12D5, r12DD), 0x01));
+
+ body.emit(assign(r12D4, lshift(r12D4, body.constant(int(16))), 0x01));
+
+ body.emit(assign(r12D2, add(r12D2, r12D4), 0x01));
+
+ ir_expression *const r12DE = less(r12D2, r12D4);
+ ir_expression *const r12DF = expr(ir_unop_b2i, r12DE);
+ ir_expression *const r12E0 = expr(ir_unop_i2u, r12DF);
+ body.emit(assign(r12D5, add(r12D5, r12E0), 0x01));
+
+ ir_variable *const r12E1 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r12E1);
+ body.emit(assign(r12E1, add(r12D2, r12C6), 0x01));
+
+ ir_variable *const r12E2 = new(mem_ctx) ir_variable(glsl_type::uint_type, "borrow1", ir_var_auto);
+ body.emit(r12E2);
+ ir_variable *const r12E3 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r12E3);
+ ir_variable *const r12E4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r12E4);
+ ir_expression *const r12E5 = less(body.constant(0u), r12C3);
+ ir_expression *const r12E6 = expr(ir_unop_b2i, r12E5);
+ body.emit(assign(r12E2, expr(ir_unop_i2u, r12E6), 0x01));
+
+ body.emit(assign(r12E3, sub(r1103, r12E1), 0x01));
+
+ ir_expression *const r12E7 = less(r12E1, r12D2);
+ ir_expression *const r12E8 = expr(ir_unop_b2i, r12E7);
+ ir_expression *const r12E9 = expr(ir_unop_i2u, r12E8);
+ ir_expression *const r12EA = add(r12D5, r12E9);
+ body.emit(assign(r12E4, sub(r1104, r12EA), 0x01));
+
+ ir_expression *const r12EB = less(r12E3, r12E2);
+ ir_expression *const r12EC = expr(ir_unop_b2i, r12EB);
+ ir_expression *const r12ED = expr(ir_unop_i2u, r12EC);
+ body.emit(assign(r12E4, sub(r12E4, r12ED), 0x01));
+
+ body.emit(assign(r12E3, sub(r12E3, r12E2), 0x01));
+
+ ir_expression *const r12EE = less(r1103, r12E1);
+ ir_expression *const r12EF = expr(ir_unop_b2i, r12EE);
+ ir_expression *const r12F0 = expr(ir_unop_i2u, r12EF);
+ body.emit(assign(r12E4, sub(r12E4, r12F0), 0x01));
+
+ body.emit(assign(r1104, r12E4, 0x01));
+
+ body.emit(assign(r1103, r12E3, 0x01));
+
+ body.emit(assign(r1102, neg(r12C3), 0x01));
+
+ /* LOOP BEGIN */
+ ir_loop *f12F1 = new(mem_ctx) ir_loop();
+ exec_list *const f12F1_parent_instructions = body.instructions;
+
+ body.instructions = &f12F1->body_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r12F3 = gequal(r1104, body.constant(0u));
+ ir_if *f12F2 = new(mem_ctx) ir_if(operand(r12F3).val);
+ exec_list *const f12F2_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f12F2->then_instructions;
+
+ body.emit(new(mem_ctx) ir_loop_jump(ir_loop_jump::jump_break));
+
+
+ body.instructions = f12F2_parent_instructions;
+ body.emit(f12F2);
+
+ /* END IF */
+
+ body.emit(assign(r1106, add(r1106, body.constant(4294967295u)), 0x01));
+
+ ir_variable *const r12F4 = new(mem_ctx) ir_variable(glsl_type::uint_type, "carry1", ir_var_auto);
+ body.emit(r12F4);
+ ir_variable *const r12F5 = new(mem_ctx) ir_variable(glsl_type::uint_type, "carry0", ir_var_auto);
+ body.emit(r12F5);
+ ir_variable *const r12F6 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r12F6);
+ ir_variable *const r12F7 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r12F7);
+ ir_variable *const r12F8 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r12F8);
+ body.emit(assign(r12F6, add(r1102, r121A), 0x01));
+
+ ir_expression *const r12F9 = less(r12F6, r1102);
+ ir_expression *const r12FA = expr(ir_unop_b2i, r12F9);
+ body.emit(assign(r12F4, expr(ir_unop_i2u, r12FA), 0x01));
+
+ body.emit(assign(r12F7, add(r1103, r121B), 0x01));
+
+ ir_expression *const r12FB = less(r12F7, r1103);
+ ir_expression *const r12FC = expr(ir_unop_b2i, r12FB);
+ body.emit(assign(r12F5, expr(ir_unop_i2u, r12FC), 0x01));
+
+ body.emit(assign(r12F7, add(r12F7, r12F4), 0x01));
+
+ ir_expression *const r12FD = less(r12F7, r12F4);
+ ir_expression *const r12FE = expr(ir_unop_b2i, r12FD);
+ ir_expression *const r12FF = expr(ir_unop_i2u, r12FE);
+ body.emit(assign(r12F8, add(r1104, r12FF), 0x01));
+
+ body.emit(assign(r12F8, add(r12F8, r12F5), 0x01));
+
+ body.emit(assign(r1104, r12F8, 0x01));
+
+ body.emit(assign(r1103, r12F7, 0x01));
+
+ body.emit(assign(r1102, r12F6, 0x01));
+
+ /* LOOP END */
+
+ body.instructions = f12F1_parent_instructions;
+ body.emit(f12F1);
+
+ ir_expression *const r1300 = bit_or(r1104, r1103);
+ ir_expression *const r1301 = bit_or(r1300, r1102);
+ ir_expression *const r1302 = nequal(r1301, body.constant(0u));
+ ir_expression *const r1303 = expr(ir_unop_b2i, r1302);
+ ir_expression *const r1304 = expr(ir_unop_i2u, r1303);
+ body.emit(assign(r1106, bit_or(r1106, r1304), 0x01));
+
+
+ body.instructions = f12C0_parent_instructions;
+ body.emit(f12C0);
+
+ /* END IF */
+
+ ir_variable *const r1305 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r1305);
+ ir_variable *const r1306 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1306);
+ ir_variable *const r1307 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1307);
+ body.emit(assign(r1305, lshift(r1106, body.constant(int(21))), 0x01));
+
+ ir_expression *const r1308 = lshift(r1107, body.constant(int(21)));
+ ir_expression *const r1309 = rshift(r1106, body.constant(int(11)));
+ body.emit(assign(r1306, bit_or(r1308, r1309), 0x01));
+
+ body.emit(assign(r1307, rshift(r1107, body.constant(int(11))), 0x01));
+
+ body.emit(assign(r1305, bit_or(r1305, body.constant(0u)), 0x01));
+
+ body.emit(assign(r1107, r1307, 0x01));
+
+ body.emit(assign(r1106, r1306, 0x01));
+
+ ir_variable *const r130A = body.make_temp(glsl_type::uint_type, "zExp");
+ body.emit(assign(r130A, r110A, 0x01));
+
+ ir_variable *const r130B = body.make_temp(glsl_type::uint_type, "zFrac0");
+ body.emit(assign(r130B, r1307, 0x01));
+
+ ir_variable *const r130C = body.make_temp(glsl_type::uint_type, "zFrac1");
+ body.emit(assign(r130C, r1306, 0x01));
+
+ ir_variable *const r130D = body.make_temp(glsl_type::uint_type, "zFrac2");
+ body.emit(assign(r130D, r1305, 0x01));
+
+ ir_variable *const r130E = body.make_temp(glsl_type::bool_type, "execute_flag");
+ body.emit(assign(r130E, body.constant(true), 0x01));
+
+ ir_variable *const r130F = body.make_temp(glsl_type::uvec2_type, "return_value");
+ ir_variable *const r1310 = new(mem_ctx) ir_variable(glsl_type::uint_type, "increment", ir_var_auto);
+ body.emit(r1310);
+ ir_expression *const r1311 = less(r1305, body.constant(0u));
+ ir_expression *const r1312 = expr(ir_unop_b2i, r1311);
+ body.emit(assign(r1310, expr(ir_unop_i2u, r1312), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r1314 = lequal(body.constant(2045u), r110A);
+ ir_if *f1313 = new(mem_ctx) ir_if(operand(r1314).val);
+ exec_list *const f1313_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1313->then_instructions;
+
+ ir_variable *const r1315 = body.make_temp(glsl_type::bool_type, "or_tmp");
+ /* IF CONDITION */
+ ir_expression *const r1317 = less(body.constant(2045u), r110A);
+ ir_if *f1316 = new(mem_ctx) ir_if(operand(r1317).val);
+ exec_list *const f1316_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1316->then_instructions;
+
+ body.emit(assign(r1315, body.constant(true), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1316->else_instructions;
+
+ ir_variable *const r1318 = body.make_temp(glsl_type::bool_type, "and_tmp");
+ /* IF CONDITION */
+ ir_expression *const r131A = equal(r110A, body.constant(2045u));
+ ir_if *f1319 = new(mem_ctx) ir_if(operand(r131A).val);
+ exec_list *const f1319_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1319->then_instructions;
+
+ ir_expression *const r131B = equal(body.constant(2097151u), r1307);
+ ir_expression *const r131C = equal(body.constant(4294967295u), r1306);
+ body.emit(assign(r1318, logic_and(r131B, r131C), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1319->else_instructions;
+
+ body.emit(assign(r1318, body.constant(false), 0x01));
+
+
+ body.instructions = f1319_parent_instructions;
+ body.emit(f1319);
+
+ /* END IF */
+
+ ir_expression *const r131D = nequal(r1310, body.constant(0u));
+ body.emit(assign(r1315, logic_and(r1318, r131D), 0x01));
+
+
+ body.instructions = f1316_parent_instructions;
+ body.emit(f1316);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f131E = new(mem_ctx) ir_if(operand(r1315).val);
+ exec_list *const f131E_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f131E->then_instructions;
+
+ ir_variable *const r131F = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r131F);
+ ir_expression *const r1320 = lshift(r110D, body.constant(int(31)));
+ body.emit(assign(r131F, add(r1320, body.constant(2146435072u)), 0x01));
+
+ body.emit(assign(r131F, body.constant(0u), 0x02));
+
+ body.emit(assign(r130F, r131F, 0x03));
+
+ body.emit(assign(r130E, body.constant(false), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f131E->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1322 = less(r110A, body.constant(0u));
+ ir_if *f1321 = new(mem_ctx) ir_if(operand(r1322).val);
+ exec_list *const f1321_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1321->then_instructions;
+
+ ir_variable *const r1323 = body.make_temp(glsl_type::uint_type, "a2");
+ body.emit(assign(r1323, r1305, 0x01));
+
+ ir_variable *const r1324 = body.make_temp(glsl_type::int_type, "count");
+ ir_expression *const r1325 = neg(r110A);
+ body.emit(assign(r1324, expr(ir_unop_u2i, r1325), 0x01));
+
+ ir_variable *const r1326 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z2", ir_var_auto);
+ body.emit(r1326);
+ ir_variable *const r1327 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1327);
+ ir_variable *const r1328 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z0", ir_var_auto);
+ body.emit(r1328);
+ ir_variable *const r1329 = body.make_temp(glsl_type::int_type, "assignment_tmp");
+ ir_expression *const r132A = neg(r1324);
+ body.emit(assign(r1329, bit_and(r132A, body.constant(int(31))), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r132C = equal(r1324, body.constant(int(0)));
+ ir_if *f132B = new(mem_ctx) ir_if(operand(r132C).val);
+ exec_list *const f132B_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f132B->then_instructions;
+
+ body.emit(assign(r1326, r1305, 0x01));
+
+ body.emit(assign(r1327, r1306, 0x01));
+
+ body.emit(assign(r1328, r1307, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f132B->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r132E = less(r1324, body.constant(int(32)));
+ ir_if *f132D = new(mem_ctx) ir_if(operand(r132E).val);
+ exec_list *const f132D_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f132D->then_instructions;
+
+ body.emit(assign(r1326, lshift(r1306, r1329), 0x01));
+
+ ir_expression *const r132F = lshift(r1307, r1329);
+ ir_expression *const r1330 = rshift(r1306, r1324);
+ body.emit(assign(r1327, bit_or(r132F, r1330), 0x01));
+
+ body.emit(assign(r1328, rshift(r1307, r1324), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f132D->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1332 = equal(r1324, body.constant(int(32)));
+ ir_if *f1331 = new(mem_ctx) ir_if(operand(r1332).val);
+ exec_list *const f1331_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1331->then_instructions;
+
+ body.emit(assign(r1326, r1306, 0x01));
+
+ body.emit(assign(r1327, r1307, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1331->else_instructions;
+
+ body.emit(assign(r1323, bit_or(r1305, r1306), 0x01));
+
+ /* IF CONDITION */
+ ir_expression *const r1334 = less(r1324, body.constant(int(64)));
+ ir_if *f1333 = new(mem_ctx) ir_if(operand(r1334).val);
+ exec_list *const f1333_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1333->then_instructions;
+
+ body.emit(assign(r1326, lshift(r1307, r1329), 0x01));
+
+ ir_expression *const r1335 = bit_and(r1324, body.constant(int(31)));
+ body.emit(assign(r1327, rshift(r1307, r1335), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1333->else_instructions;
+
+ ir_variable *const r1336 = body.make_temp(glsl_type::uint_type, "conditional_tmp");
+ /* IF CONDITION */
+ ir_expression *const r1338 = equal(r1324, body.constant(int(64)));
+ ir_if *f1337 = new(mem_ctx) ir_if(operand(r1338).val);
+ exec_list *const f1337_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1337->then_instructions;
+
+ body.emit(assign(r1336, r1307, 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1337->else_instructions;
+
+ ir_expression *const r1339 = nequal(r1307, body.constant(0u));
+ ir_expression *const r133A = expr(ir_unop_b2i, r1339);
+ body.emit(assign(r1336, expr(ir_unop_i2u, r133A), 0x01));
+
+
+ body.instructions = f1337_parent_instructions;
+ body.emit(f1337);
+
+ /* END IF */
+
+ body.emit(assign(r1326, r1336, 0x01));
+
+ body.emit(assign(r1327, body.constant(0u), 0x01));
+
+
+ body.instructions = f1333_parent_instructions;
+ body.emit(f1333);
+
+ /* END IF */
+
+
+ body.instructions = f1331_parent_instructions;
+ body.emit(f1331);
+
+ /* END IF */
+
+ body.emit(assign(r1328, body.constant(0u), 0x01));
+
+
+ body.instructions = f132D_parent_instructions;
+ body.emit(f132D);
+
+ /* END IF */
+
+ ir_expression *const r133B = nequal(r1323, body.constant(0u));
+ ir_expression *const r133C = expr(ir_unop_b2i, r133B);
+ ir_expression *const r133D = expr(ir_unop_i2u, r133C);
+ body.emit(assign(r1326, bit_or(r1326, r133D), 0x01));
+
+
+ body.instructions = f132B_parent_instructions;
+ body.emit(f132B);
+
+ /* END IF */
+
+ body.emit(assign(r130B, r1328, 0x01));
+
+ body.emit(assign(r130C, r1327, 0x01));
+
+ body.emit(assign(r130D, r1326, 0x01));
+
+ body.emit(assign(r130A, body.constant(0u), 0x01));
+
+ ir_expression *const r133E = less(r1326, body.constant(0u));
+ ir_expression *const r133F = expr(ir_unop_b2i, r133E);
+ body.emit(assign(r1310, expr(ir_unop_i2u, r133F), 0x01));
+
+
+ body.instructions = f1321_parent_instructions;
+ body.emit(f1321);
+
+ /* END IF */
+
+
+ body.instructions = f131E_parent_instructions;
+ body.emit(f131E);
+
+ /* END IF */
+
+
+ body.instructions = f1313_parent_instructions;
+ body.emit(f1313);
+
+ /* END IF */
+
+ /* IF CONDITION */
+ ir_if *f1340 = new(mem_ctx) ir_if(operand(r130E).val);
+ exec_list *const f1340_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1340->then_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r1342 = nequal(r1310, body.constant(0u));
+ ir_if *f1341 = new(mem_ctx) ir_if(operand(r1342).val);
+ exec_list *const f1341_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f1341->then_instructions;
+
+ ir_variable *const r1343 = new(mem_ctx) ir_variable(glsl_type::uint_type, "z1", ir_var_auto);
+ body.emit(r1343);
+ body.emit(assign(r1343, add(r130C, body.constant(1u)), 0x01));
+
+ ir_expression *const r1344 = less(r1343, r130C);
+ ir_expression *const r1345 = expr(ir_unop_b2i, r1344);
+ ir_expression *const r1346 = expr(ir_unop_i2u, r1345);
+ body.emit(assign(r130B, add(r130B, r1346), 0x01));
+
+ ir_expression *const r1347 = neg(r130D);
+ ir_expression *const r1348 = equal(r130D, r1347);
+ ir_expression *const r1349 = expr(ir_unop_b2i, r1348);
+ ir_expression *const r134A = expr(ir_unop_i2u, r1349);
+ ir_expression *const r134B = bit_and(r134A, body.constant(1u));
+ ir_expression *const r134C = expr(ir_unop_bit_not, r134B);
+ body.emit(assign(r130C, bit_and(r1343, r134C), 0x01));
+
+
+ /* ELSE INSTRUCTIONS */
+ body.instructions = &f1341->else_instructions;
+
+ /* IF CONDITION */
+ ir_expression *const r134E = bit_or(r130B, r130C);
+ ir_expression *const r134F = equal(r134E, body.constant(0u));
+ ir_if *f134D = new(mem_ctx) ir_if(operand(r134F).val);
+ exec_list *const f134D_parent_instructions = body.instructions;
+
+ /* THEN INSTRUCTIONS */
+ body.instructions = &f134D->then_instructions;
+
+ body.emit(assign(r130A, body.constant(0u), 0x01));
+
+
+ body.instructions = f134D_parent_instructions;
+ body.emit(f134D);
+
+ /* END IF */
+
+
+ body.instructions = f1341_parent_instructions;
+ body.emit(f1341);
+
+ /* END IF */
+
+ ir_variable *const r1350 = new(mem_ctx) ir_variable(glsl_type::uvec2_type, "z", ir_var_auto);
+ body.emit(r1350);
+ ir_expression *const r1351 = lshift(r110D, body.constant(int(31)));
+ ir_expression *const r1352 = lshift(r130A, body.constant(int(20)));
+ ir_expression *const r1353 = add(r1351, r1352);
+ body.emit(assign(r1350, add(r1353, r130B), 0x01));
+
+ body.emit(assign(r1350, r130C, 0x02));
+
+ body.emit(assign(r130F, r1350, 0x03));
+
+ body.emit(assign(r130E, body.constant(false), 0x01));
+
+
+ body.instructions = f1340_parent_instructions;
+ body.emit(f1340);
+
+ /* END IF */
+
+ body.emit(assign(r1101, r130F, 0x03));
+
+ body.emit(assign(r1100, body.constant(false), 0x01));
+
+
+ body.instructions = f1213_parent_instructions;
+ body.emit(f1213);
+
+ /* END IF */
+
+
+ body.instructions = f11CC_parent_instructions;
+ body.emit(f11CC);
+
+ /* END IF */
+
+
+ body.instructions = f115D_parent_instructions;
+ body.emit(f115D);
+
+ /* END IF */
+
+
+ body.instructions = f1116_parent_instructions;
+ body.emit(f1116);
+
+ /* END IF */
+
+ body.emit(ret(r1101));
+
+ sig->replace_parameters(&sig_parameters);
+ return sig;
+}
diff --git a/src/compiler/glsl/builtin_functions.cpp b/src/compiler/glsl/builtin_functions.cpp
index 43e622b74f..d754d82cd2 100644
--- a/src/compiler/glsl/builtin_functions.cpp
+++ b/src/compiler/glsl/builtin_functions.cpp
@@ -3157,6 +3157,10 @@ builtin_builder::create_builtins()
generate_ir::fmul64(mem_ctx, integer_functions_supported),
NULL);
+ add_function("__builtin_fdiv64",
+ generate_ir::fdiv64(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 e141aa792a..efbd8315c6 100644
--- a/src/compiler/glsl/builtin_functions.h
+++ b/src/compiler/glsl/builtin_functions.h
@@ -84,6 +84,9 @@ fadd64(void *mem_ctx, builtin_available_predicate avail);
ir_function_signature *
fmul64(void *mem_ctx, builtin_available_predicate avail);
+ir_function_signature *
+fdiv64(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 372db0e94f..658d19076a 100644
--- a/src/compiler/glsl/float64.glsl
+++ b/src/compiler/glsl/float64.glsl
@@ -920,3 +920,249 @@ fmul64( uvec2 a, uvec2 b )
}
return roundAndPackFloat64( zSign, zExp, zFrac0, zFrac1, zFrac2 );
}
+
+/* Adds the 96-bit value formed by concatenating `a0', `a1', and `a2' to the
+ * 96-bit value formed by concatenating `b0', `b1', and `b2'. Addition is
+ * modulo 2^96, so any carry out is lost. The result is broken into three
+ * 32-bit pieces which are stored at the locations pointed to by `z0Ptr',
+ * `z1Ptr', and `z2Ptr'.
+ */
+void
+add96( uint a0, uint a1, uint a2,
+ uint b0, uint b1, uint b2,
+ inout uint z0Ptr,
+ inout uint z1Ptr,
+ inout uint z2Ptr )
+{
+ uint z0;
+ uint z1;
+ uint z2;
+ uint carry0;
+ uint carry1;
+
+ z2 = a2 + b2;
+ carry1 = uint ( z2 < a2 );
+ z1 = a1 + b1;
+ carry0 = uint ( z1 < a1 );
+ z0 = a0 + b0;
+ z1 += carry1;
+ z0 += uint ( z1 < carry1 );
+ z0 += carry0;
+ z2Ptr = z2;
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Subtracts the 96-bit value formed by concatenating `b0', `b1', and `b2' from
+ * the 96-bit value formed by concatenating `a0', `a1', and `a2'. Subtraction
+ * is modulo 2^96, so any borrow out (carry out) is lost. The result is broken
+ * into three 32-bit pieces which are stored at the locations pointed to by
+ * `z0Ptr', `z1Ptr', and `z2Ptr'.
+ */
+void
+sub96( uint a0, uint a1, uint a2,
+ uint b0, uint b1, uint b2,
+ inout uint z0Ptr,
+ inout uint z1Ptr,
+ inout uint z2Ptr )
+{
+ uint z0;
+ uint z1;
+ uint z2;
+ uint borrow0;
+ uint borrow1;
+
+ z2 = a2 - b2;
+ borrow1 = uint ( a2 < b2 );
+ z1 = a1 - b1;
+ borrow0 = uint ( a1 < b1 );
+ z0 = a0 - b0;
+ z0 -= uint ( z1 < borrow1 );
+ z1 -= borrow1;
+ z0 -= borrow0;
+ z2Ptr = z2;
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Shifts the 64-bit value formed by concatenating `a0' and `a1' right by the
+ * number of bits given in `count'. Any bits shifted off are lost. The value
+ * of `count' can be arbitrarily large; in particular, if `count' is greater
+ * than 64, the result will be 0. The result is broken into two 32-bit pieces
+ * which are stored at the locations pointed to by `z0Ptr' and `z1Ptr'.
+ */
+void
+shift64Right( uint a0, uint a1,
+ int count,
+ inout uint z0Ptr,
+ inout uint z1Ptr )
+{
+ uint z0;
+ uint z1;
+ int negCount = ( - count ) & 31;
+
+ if ( count == 0 ) {
+ z1 = a1;
+ z0 = a0;
+ }
+ else if ( count < 32 ) {
+ z1 = ( a0<<negCount ) | ( a1>>count );
+ z0 = a0>>count;
+ }
+ else {
+ z1 = ( count < 64 ) ? ( a0>>( count & 31 ) ) : 0u;
+ z0 = 0u;
+ }
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Returns an approximation to the 32-bit integer quotient obtained by dividing
+ * `b' into the 64-bit value formed by concatenating `a0' and `a1'. The
+ * divisor `b' must be at least 2^31. If q is the exact quotient truncated
+ * toward zero, the approximation returned lies between q and q + 2 inclusive.
+ * If the exact quotient q is larger than 32 bits, the maximum positive 32-bit
+ * unsigned integer is returned.
+ */
+uint
+estimateDiv64To32( uint a0, uint a1, uint b )
+{
+ uint b0;
+ uint b1;
+ uint rem0 = 0u;
+ uint rem1 = 0u;
+ uint term0 = 0u;
+ uint term1 = 0u;
+ uint z;
+
+ if ( b <= a0 )
+ return 0xFFFFFFFFu;
+ b0 = b>>16;
+ z = ( b0<<16 <= a0 ) ? 0xFFFF0000u : ( a0 / b0 )<<16;
+ mul32To64( b, z, term0, term1 );
+ sub64( a0, a1, term0, term1, rem0, rem1 );
+ while ( rem0 < 0u ) {
+ z -= 0x10000u;
+ b1 = b<<16;
+ add64( rem0, rem1, b0, b1, rem0, rem1 );
+ }
+ rem0 = ( rem0<<16 ) | ( rem1>>16 );
+ z |= ( b0<<16 <= rem0 ) ? 0xFFFFu : rem0 / b0;
+ return z;
+}
+
+/* Multiplies the 64-bit value formed by concatenating `a0' and `a1' by `b'
+ * to obtain a 96-bit product. The product is broken into three 32-bit pieces
+ * which are stored at the locations pointed to by `z0Ptr', `z1Ptr', and
+ * `z2Ptr'.
+ */
+void
+mul64By32To96( uint a0, uint a1,
+ uint b,
+ inout uint z0Ptr,
+ inout uint z1Ptr,
+ inout uint z2Ptr )
+{
+ uint z0 = 0u;
+ uint z1 = 0u;
+ uint z2 = 0u;
+ uint more1 = 0u;
+
+ mul32To64( a1, b, z1, z2 );
+ mul32To64( a0, b, z0, more1 );
+ add64( z0, more1, 0u, z1, z0, z1 );
+ z2Ptr = z2;
+ z1Ptr = z1;
+ z0Ptr = z0;
+}
+
+/* Returns the result of dividing the double-precision floating-point value
+ * `a' by the corresponding value `b'. The operation is performed according to
+ * the IEEE Standard for Floating-Point Arithmetic.
+ */
+uvec2
+fdiv64( 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 rem0 = 0u;
+ uint rem1 = 0u;
+ uint rem2 = 0u;
+ uint rem3 = 0u;
+ uint term0 = 0u;
+ uint term1 = 0u;
+ uint term2 = 0u;
+ uint term3 = 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 )
+ return propagateFloat64NaN( a, b );
+ if ( bExp == 0x7FFu ) {
+ if ( ( bFrac.x | bFrac.y ) != 0u )
+ return propagateFloat64NaN( a, b );
+ return uvec2( 0xFFFFFFFFu, 0xFFFFFFFFu );
+ }
+ return packFloat64( zSign, 0x7FFu, 0u, 0u );
+ }
+ if ( bExp == 0x7FFu ) {
+ if ( ( bFrac.x | bFrac.y ) != 0u )
+ return propagateFloat64NaN( a, b );
+ return packFloat64( zSign, 0u, 0u, 0u );
+ }
+ if ( bExp == 0u ) {
+ if ( ( bFrac.x | bFrac.y ) == 0u ) {
+ if ( ( aExp | aFrac.x | aFrac.y ) == 0u ) {
+ return uvec2( 0xFFFFFFFFu, 0xFFFFFFFFu );
+ }
+ return packFloat64( zSign, 0x7FFu, 0u, 0u );
+ }
+ normalizeFloat64Subnormal( bFrac.x, bFrac.y, bExp, bFrac.x, bFrac.y );
+ }
+ 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 );
+ }
+ zExp = aExp - bExp + 0x3FDu;
+ shortShift64Left( aFrac.x | 0x00100000u, aFrac.y, 11, aFrac.x, aFrac.y );
+ shortShift64Left( bFrac.x | 0x00100000u, bFrac.y, 11, bFrac.x, bFrac.y );
+ if ( le64( bFrac.x, bFrac.y, aFrac.x, aFrac.y ) ) {
+ shift64Right( aFrac.x, aFrac.y, 1, aFrac.x, aFrac.y );
+ ++zExp;
+ }
+ zFrac0 = estimateDiv64To32( aFrac.x, aFrac.y, bFrac.x );
+ mul64By32To96( bFrac.x, bFrac.y, zFrac0, term0, term1, term2 );
+ sub96( aFrac.x, aFrac.y, 0u, term0, term1, term2, rem0, rem1, rem2 );
+ while ( rem0 < 0u ) {
+ --zFrac0;
+ add96( rem0, rem1, rem2, 0u, bFrac.x, bFrac.y, rem0, rem1, rem2 );
+ }
+ zFrac1 = estimateDiv64To32( rem1, rem2, bFrac.x );
+ if ( ( zFrac1 & 0x3FFu ) <= 4u ) {
+ mul64By32To96( bFrac.x, bFrac.y, zFrac1, term1, term2, term3 );
+ sub96( rem1, rem2, 0u, term1, term2, term3, rem1, rem2, rem3 );
+ while ( rem1 < 0u ) {
+ --zFrac1;
+ add96( rem1, rem2, rem3, 0u, bFrac.x, bFrac.y, rem1, rem2, rem3 );
+ }
+ zFrac1 |= uint ( ( ( rem1 | rem2 | rem3 ) != 0u ) );
+ }
+ shift64ExtraRightJamming( zFrac0, zFrac1, 0u, 11, zFrac0, zFrac1, zFrac2 );
+ return roundAndPackFloat64( zSign, zExp, zFrac0, zFrac1, zFrac2 );
+}
--
2.11.0
More information about the mesa-dev
mailing list