x86_64: rewrite scalar and vector int `@divTrunc`

1 files changed, 2767 insertions, 1101 deletions

diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 74b9c59112..8c2aaa2d32 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -2418,7 +2418,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
 }
 
 fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
-    @setEvalBranchQuota(12_200);
+    @setEvalBranchQuota(12_300);
     const pt = cg.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
@@ -7785,1068 +7785,1726 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
-            .div_trunc, .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: {
+            .div_trunc => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
-                if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag);
                 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
                 var res: [1]Temp = undefined;
-                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) {
-                    else => unreachable,
-                    .div_trunc => .zero,
-                    .div_floor => .down,
-                })) {
-                    else => unreachable,
-                    inline .zero, .down => |direction| comptime &.{ .{
-                        .required_features = .{ .f16c, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .word, .is = .word } },
-                            .{ .scalar_float = .{ .of = .word, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .extra_temps = .{
-                            .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
-                            .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
-                            .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
-                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
-                            .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
-                            .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
-                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .word, .is = .word } },
-                            .{ .scalar_float = .{ .of = .word, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "__trunch",
-                                .down => "__floorh",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .f16c, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .qword, .is = .word } },
-                            .{ .scalar_float = .{ .of = .qword, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .mem, .mem, .none } },
-                            .{ .src = .{ .to_sse, .mem, .none } },
-                            .{ .src = .{ .mem, .to_sse, .none } },
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .extra_temps = .{
-                            .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
-                            .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
-                            .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
-                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
-                            .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
-                            .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                            .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .f16c, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .xword, .is = .word } },
-                            .{ .scalar_float = .{ .of = .xword, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .mem, .mem, .none } },
-                            .{ .src = .{ .to_sse, .mem, .none } },
-                            .{ .src = .{ .mem, .to_sse, .none } },
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .extra_temps = .{
-                            .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
-                            .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
-                            .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
-                            .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
-                            .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
-                            .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                            .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .f16c, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
-                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
-                            .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
-                            .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
-                            .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                            .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
-                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "__trunch",
-                                .down => "__floorh",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
-                            .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
-                            .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
-                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                            .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse4_1, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
-                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "__trunch",
-                                .down => "__floorh",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                            .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
-                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
-                            .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
-                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                            .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse2, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
-                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "__trunch",
-                                .down => "__floorh",
-                            } } } },
-                            .{ .type = .f16, .kind = .{ .reg = .ax } },
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
-                            .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
-                            .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
-                            .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
-                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                            .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
-                            .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
-                            .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f16, .kind = .{ .reg = .ax } },
-                            .{ .type = .f32, .kind = .mem },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "__trunch",
-                                .down => "__floorh",
-                            } } } },
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
-                            .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
-                            .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
-                            .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
-                            .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
-                            .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
-                            .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
-                            .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
-                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_sse, .mem, .none } },
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
-                            .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse4_1, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
-                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mut_sse, .mem, .none } },
-                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
-                            .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
-                            .{ .scalar_float = .{ .of = .dword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "truncf",
-                                .down => "floorf",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
-                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .xword, .is = .dword } },
-                            .{ .scalar_float = .{ .of = .xword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_sse, .mem, .none } },
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
-                            .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse4_1, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .xword, .is = .dword } },
-                            .{ .scalar_float = .{ .of = .xword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mut_sse, .mem, .none } },
-                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
-                            .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
-                            .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "truncf",
-                                .down => "floorf",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .yword, .is = .dword } },
-                            .{ .scalar_float = .{ .of = .yword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_sse, .mem, .none } },
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
-                            .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
-                            .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
-                            .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                            .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse4_1, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                            .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
-                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_sse, .mem, .none } },
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
-                            .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }) },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse4_1, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
-                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mut_sse, .mem, .none } },
-                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
-                            .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse2, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
-                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "trunc",
-                                .down => "floor",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
-                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
-                            .{ .scalar_float = .{ .of = .qword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "trunc",
-                                .down => "floor",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .xword, .is = .qword } },
-                            .{ .scalar_float = .{ .of = .xword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_sse, .mem, .none } },
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
-                            .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse4_1, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .xword, .is = .qword } },
-                            .{ .scalar_float = .{ .of = .xword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mut_sse, .mem, .none } },
-                            .{ .src = .{ .to_mut_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
-                            .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .yword, .is = .qword } },
-                            .{ .scalar_float = .{ .of = .yword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_sse, .mem, .none } },
-                            .{ .src = .{ .to_sse, .to_sse, .none } },
-                        },
-                        .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
-                        .each = .{ .once = &.{
-                            .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
-                            .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
-                            .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
-                            .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                            .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse4_1, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
-                            .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse2, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
-                            .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "trunc",
-                                .down => "floor",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
-                            .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
-                            .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "trunc",
-                                .down => "floor",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
-                            .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
-                            .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                            .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .x87, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
-                            .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .size = 16, .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
-                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
-                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "__truncx",
-                                .down => "__floorx",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .reg = .st0 }, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
-                            .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
-                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
-                            .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .x87, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .size = 16, .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f80, .kind = .{ .reg = .st6 } },
-                            .{ .type = .f80, .kind = .{ .reg = .st7 } },
-                            .{ .type = .f80, .kind = .{ .frame = .call_frame } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "__truncx",
-                                .down => "__floorx",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                            .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                            .{ ._, .f_p, .div, ._, ._, ._, ._ },
-                            .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                            .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
-                            .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse, null, null, null },
-                        .src_constraints = .{
-                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
-                            .{ .scalar_float = .{ .of = .xword, .is = .xword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "truncq",
-                                .down => "floorq",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .{ .ref = .src0 }, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .avx, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "truncq",
-                                .down => "floorq",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                            .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
-                        } },
-                    }, .{
-                        .required_features = .{ .sse2, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "truncq",
-                                .down => "floorq",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                            .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
+                    .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                        .{ .src = .{ .to_gpr, .mem, .none } },
+                        .{ .src = .{ .mem, .to_gpr, .none } },
+                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
+                    },
+                    .dst_temps = .{ .{ .reg = .al }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
+                        .{ ._, .i_, .div, .src1b, ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                        .{ .src = .{ .to_gpr, .mem, .none } },
+                        .{ .src = .{ .mem, .to_gpr, .none } },
+                        .{ .src = .{ .to_gpr, .to_gpr, .none } },
+                    },
+                    .dst_temps = .{ .{ .reg = .al }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
+                        .{ ._, ._, .div, .src1b, ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
+                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .i16, .kind = .{ .reg = .dx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .cwd, ._, ._, ._, ._ },
+                        .{ ._, .i_, .div, .src1w, ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
+                        .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u16, .kind = .{ .reg = .dx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
+                        .{ ._, ._, .div, .src1w, ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
+                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .i32, .kind = .{ .reg = .edx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .cdq, ._, ._, ._, ._ },
+                        .{ ._, .i_, .div, .src1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
+                        .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u32, .kind = .{ .reg = .edx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
+                        .{ ._, ._, .div, .src1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
+                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .cqo, ._, ._, ._, ._ },
+                        .{ ._, .i_, .div, .src1q, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
+                        .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .xor, .tmp0q, .tmp0q, ._, ._ },
+                        .{ ._, ._, .div, .src1q, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } },
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } },
+                            .none,
                         } },
-                    }, .{
-                        .required_features = .{ .sse, null, null, null },
-                        .src_constraints = .{
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
-                            .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
-                            .any,
-                        },
-                        .patterns = &.{
-                            .{ .src = .{ .to_mem, .to_mem, .none } },
-                        },
-                        .call_frame = .{ .alignment = .@"16" },
-                        .extra_temps = .{
-                            .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
-                            .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
-                            .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
-                                else => unreachable,
-                                .zero => "truncq",
-                                .down => "floorq",
-                            } } } },
-                            .unused,
-                            .unused,
-                            .unused,
-                            .unused,
-                        },
-                        .dst_temps = .{ .mem, .unused },
-                        .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
-                        .each = .{ .once = &.{
-                            .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
-                            .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
-                            .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
-                            .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
-                            .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
-                            .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
-                            .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
+                    .patterns = &.{
+                        .{ .src = .{
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } },
+                            .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } },
+                            .none,
                         } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
                     } },
-                }) catch |err| switch (err) {
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{
+                        .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
+                        .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{
+                        .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
+                        .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .slow_incdec, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
+                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i8, .kind = .{ .reg = .al } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{
+                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
+                        .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i8, .kind = .{ .reg = .al } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
+                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
+                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .slow_incdec, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u8, .kind = .{ .reg = .al } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u8, .kind = .{ .reg = .al } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
+                        .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
+                        .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{
+                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i16, .kind = .{ .reg = .ax } },
+                        .{ .type = .i16, .kind = .{ .reg = .dx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .cwd, ._, ._, ._, ._ },
+                        .{ ._, .i_, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u16, .kind = .{ .reg = .ax } },
+                        .{ .type = .u16, .kind = .{ .reg = .dx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
+                        .{ ._, ._, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{
+                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
+                        .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i32, .kind = .{ .reg = .eax } },
+                        .{ .type = .i32, .kind = .{ .reg = .edx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .cdq, ._, ._, ._, ._ },
+                        .{ ._, .i_, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .src_constraints = .{
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u32, .kind = .{ .reg = .eax } },
+                        .{ .type = .u32, .kind = .{ .reg = .edx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
+                        .{ ._, ._, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
+                        .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .i64, .kind = .{ .reg = .rax } },
+                        .{ .type = .i64, .kind = .{ .reg = .rdx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .cqo, ._, ._, ._, ._ },
+                        .{ ._, .i_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .reg = .rax } },
+                        .{ .type = .u64, .kind = .{ .reg = .rdx } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
+                        .{ ._, ._, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+                        .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+                        .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } },
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
+                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+                        .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+                        .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } },
+                        .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } },
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
+                        .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
+                        .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
+                        .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .@"64bit", null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
+                        .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+                        .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .f16c, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
+                        .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+                        .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
+                        .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
+                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .f16c, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .mem, .to_sse, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
+                        .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+                        .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
+                        .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .f16c, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .mem, .to_sse, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
+                        .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
+                        .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
+                        .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .f16c, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
+                        .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
+                        .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+                        .{ .type = .f16, .kind = .{ .reg = .ax } },
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .reg = .ax } },
+                        .{ .type = .f32, .kind = .mem },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
+                        .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_sse, .mem, .none } },
+                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
+                        .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncf" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
+                        .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_sse, .mem, .none } },
+                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
+                        .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
+                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncf" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
+                        .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
+                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
+                        .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
+                        .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }) },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_sse, .mem, .none } },
+                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
+                        .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
+                        .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_sse, .mem, .none } },
+                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
+                        .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
+                        .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
+                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
+                        .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .size = 16, .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncx" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .size = 16, .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncx" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                } }) catch |err| switch (err) {
                     error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
                         @tagName(air_tag),
                         cg.typeOf(bin_op.lhs).fmt(pt),
@@ -9993,6 +10651,1003 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 };
                 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
             },
+            .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: {
+                const bin_op = air_datas[@intFromEnum(inst)].bin_op;
+                if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag);
+                var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
+                var res: [1]Temp = undefined;
+                cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
+                    .required_features = .{ .f16c, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
+                        .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+                        .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
+                        .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
+                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .f16c, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .mem, .to_sse, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
+                        .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+                        .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
+                        .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .f16c, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .mem, .mem, .none } },
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .mem, .to_sse, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
+                        .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
+                        .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
+                        .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                        .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .f16c, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
+                        .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
+                        .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
+                        .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                        .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
+                        .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+                        .{ .type = .f16, .kind = .{ .reg = .ax } },
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+                        .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
+                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f16, .kind = .{ .reg = .ax } },
+                        .{ .type = .f32, .kind = .mem },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
+                        .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
+                        .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
+                        .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
+                        .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
+                        .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
+                        .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_sse, .mem, .none } },
+                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
+                        .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorf" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
+                        .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_sse, .mem, .none } },
+                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
+                        .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
+                        .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorf" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
+                        .{ .scalar_float = .{ .of = .yword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
+                        .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
+                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
+                        .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                        .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
+                        .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }) },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_sse, .mem, .none } },
+                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
+                        .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
+                        .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mut_sse, .mem, .none } },
+                        .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
+                        .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
+                        .{ .scalar_float = .{ .of = .yword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_sse, .mem, .none } },
+                        .{ .src = .{ .to_sse, .to_sse, .none } },
+                    },
+                    .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+                    .each = .{ .once = &.{
+                        .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
+                        .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
+                        .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
+                        .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                        .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse4_1, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+                        .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+                        .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+                        .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
+                        .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .size = 16, .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorx" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .reg = .st0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+                        .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .x87, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .size = 16, .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f80, .kind = .{ .reg = .st6 } },
+                        .{ .type = .f80, .kind = .{ .reg = .st7 } },
+                        .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorx" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, .f_p, .div, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
+                        .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
+                        .{ .scalar_float = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .{ .ref = .src0 }, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .avx, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse2, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                }, .{
+                    .required_features = .{ .sse, null, null, null },
+                    .src_constraints = .{
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+                        .any,
+                    },
+                    .patterns = &.{
+                        .{ .src = .{ .to_mem, .to_mem, .none } },
+                    },
+                    .call_frame = .{ .alignment = .@"16" },
+                    .extra_temps = .{
+                        .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+                        .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+                        .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
+                        .unused,
+                        .unused,
+                        .unused,
+                        .unused,
+                    },
+                    .dst_temps = .{ .mem, .unused },
+                    .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+                    .each = .{ .once = &.{
+                        .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+                        .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+                        .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+                        .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+                        .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+                        .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+                        .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+                    } },
+                } }) catch |err| switch (err) {
+                    error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
+                        @tagName(air_tag),
+                        cg.typeOf(bin_op.lhs).fmt(pt),
+                        ops[0].tracking(cg),
+                        ops[1].tracking(cg),
+                    }),
+                    else => |e| return e,
+                };
+                try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
+            },
             .rem, .rem_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .rem) else fallback: {
                 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
                 if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, .rem);
@@ -37825,7 +39480,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
                 try cg.spillEflagsIfOccupied();
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
-                while (try ops[0].toBase(cg)) {}
+                while (try ops[0].toBase(false, cg)) {}
                 try cg.asmMemoryImmediate(
                     .{ ._, .cmp },
                     try ops[0].tracking(cg).short.mem(cg, .{
@@ -37850,7 +39505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
                 try cg.spillEflagsIfOccupied();
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
-                while (try ops[0].toBase(cg)) {}
+                while (try ops[0].toBase(false, cg)) {}
                 try cg.asmMemoryImmediate(
                     .{ ._, .cmp },
                     try ops[0].tracking(cg).short.mem(cg, .{
@@ -37921,7 +39576,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                 try cg.spillEflagsIfOccupied();
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
-                while (try ops[0].toBase(cg)) {}
+                while (try ops[0].toBase(false, cg)) {}
                 try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
                     .size = cg.memSize(eu_err_ty),
                     .disp = eu_err_off,
@@ -37937,7 +39592,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
                 const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
                 try cg.spillEflagsIfOccupied();
                 var ops = try cg.tempsFromOperands(inst, .{un_op});
-                while (try ops[0].toBase(cg)) {}
+                while (try ops[0].toBase(false, cg)) {}
                 try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
                     .size = cg.memSize(eu_err_ty),
                     .disp = eu_err_off,
@@ -88424,7 +90079,7 @@ const Temp = struct {
         try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
         cg.temp_type[@intFromEnum(new_temp_index)] = ty;
         new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
-        while (try temp.toBase(cg)) {}
+        while (try temp.toBase(false, cg)) {}
         try temp.readTo(ty, .{ .register = new_reg }, .{}, cg);
         try temp.die(cg);
         temp.* = .{ .index = new_temp_index.toIndex() };
@@ -88447,7 +90102,7 @@ const Temp = struct {
         for (new_regs) |new_reg| try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
         cg.temp_type[@intFromEnum(new_temp_index)] = ty;
         new_temp_index.tracking(cg).* = .init(.{ .register_pair = new_regs });
-        while (try temp.toBase(cg)) {}
+        while (try temp.toBase(false, cg)) {}
         for (new_regs, 0..) |new_reg, reg_index| try temp.readTo(
             .usize,
             .{ .register = new_reg },
@@ -88548,9 +90203,9 @@ const Temp = struct {
         }
     }
 
-    fn toMemory(temp: *Temp, cg: *CodeGen) InnerError!bool {
+    fn toMemory(temp: *Temp, mut: bool, cg: *CodeGen) InnerError!bool {
         const temp_tracking = temp.tracking(cg);
-        if (temp_tracking.short.isMemory()) return false;
+        if ((!mut or temp.isMut(cg)) and temp_tracking.short.isMemory()) return false;
         const new_temp_index = cg.next_temp_index;
         const ty = temp.typeOf(cg);
         cg.temp_type[@intFromEnum(new_temp_index)] = ty;
@@ -88564,10 +90219,10 @@ const Temp = struct {
     }
 
     // hack around linker relocation bugs
-    fn toBase(temp: *Temp, cg: *CodeGen) InnerError!bool {
+    fn toBase(temp: *Temp, mut: bool, cg: *CodeGen) InnerError!bool {
         const temp_tracking = temp.tracking(cg);
-        if (temp_tracking.short.isBase()) return false;
-        if (try temp.toMemory(cg)) return true;
+        if ((!mut or temp.isMut(cg)) and temp_tracking.short.isBase()) return false;
+        if (try temp.toMemory(mut, cg)) return true;
         const new_temp_index = cg.next_temp_index;
         cg.temp_type[@intFromEnum(new_temp_index)] = temp.typeOf(cg);
         const new_reg =
@@ -88722,7 +90377,7 @@ const Temp = struct {
 
     fn read(src: *Temp, val_ty: Type, opts: AccessOptions, cg: *CodeGen) InnerError!Temp {
         var val = try cg.tempAlloc(val_ty);
-        while (try src.toBase(cg)) {}
+        while (try src.toBase(false, cg)) {}
         try src.readTo(val_ty, val.tracking(cg).short, opts, cg);
         return val;
     }
@@ -88763,8 +90418,8 @@ const Temp = struct {
 
     fn write(dst: *Temp, val: *Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {
         const val_ty = val.typeOf(cg);
-        while (try dst.toBase(cg)) {}
-        val_to_gpr: while (true) : (while (try dst.toBase(cg) or
+        while (try dst.toBase(false, cg)) {}
+        val_to_gpr: while (true) : (while (try dst.toBase(false, cg) or
             try val.toRegClass(false, .general_purpose, cg))
         {}) {
             const val_mcv = val.tracking(cg).short;
@@ -90770,7 +92425,8 @@ const Select = struct {
             fn convert(src: Src, temp: *Temp, cg: *CodeGen) InnerError!bool {
                 return switch (src) {
                     .none, .imm8, .imm16, .imm32, .simm32 => false,
-                    .mem, .to_mem, .mut_mem, .to_mut_mem => try temp.toBase(cg),
+                    .mem, .to_mem => try temp.toBase(false, cg),
+                    .mut_mem, .to_mut_mem => try temp.toBase(true, cg),
                     .to_reg => |reg| try temp.toReg(reg, cg),
                     .to_reg_pair => |regs| try temp.toRegPair(regs, cg),
                     .to_param_gpr => |param_spec| try temp.toReg(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index], cg),
@@ -90814,6 +92470,7 @@ const Select = struct {
             rc_mask: struct { rc: Register.Class, info: MaskInfo },
             mut_rc_mask: struct { ref: Select.Operand.Ref, rc: Register.Class, info: MaskInfo },
             mem,
+            mem_of_type: Select.Operand.Ref,
             smin_mem: ConstSpec,
             smax_mem: ConstSpec,
             umin_mem: ConstSpec,
@@ -90835,9 +92492,9 @@ const Select = struct {
 
             const CallConvRegSpec = struct {
                 cc: Case.CallConv,
-                index: u1,
+                index: u2,
 
-                fn tag(spec: CallConvRegSpec, cg: *CodeGen) std.builtin.CallingConvention.Tag {
+                fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag {
                     return switch (spec.cc) {
                         .none => unreachable,
                         .ccc => cg.target.cCallingConvention().?,
@@ -90846,27 +92503,39 @@ const Select = struct {
                 }
             };
 
-            fn finish(kind: Kind, temp: Temp, s: *const Select) void {
-                switch (kind) {
-                    else => {},
-                    inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, s.cg),
+            fn lock(kind: Kind, cg: *CodeGen) ![2]?RegisterLock {
+                var reg_locks: [2]?RegisterLock = @splat(null);
+                const regs: [2]Register = switch (kind) {
+                    else => return reg_locks,
+                    .reg => |reg| .{ reg, .none },
+                    .reg_pair => |regs| regs,
+                    .param_gpr => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..1].* ++ .{.none},
+                    .param_gpr_pair => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*,
+                    .ret_gpr => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..1].* ++ .{.none},
+                    .ret_gpr_pair => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
+                };
+                for (regs, &reg_locks) |reg, *reg_lock| {
+                    if (reg == .none) continue;
+                    const reg_index = RegisterManager.indexOfRegIntoTracked(reg) orelse continue;
+                    try cg.register_manager.getRegIndex(reg_index, null);
+                    reg_lock.* = cg.register_manager.lockRegIndex(reg_index);
                 }
+                return reg_locks;
             }
 
-            fn pass(kind: Kind) u2 {
-                return switch (kind) {
-                    .unused => 0,
-                    .reg, .reg_pair, .param_gpr, .param_gpr_pair, .ret_gpr, .ret_gpr_pair => 1,
-                    else => 2,
-                };
+            fn finish(kind: Kind, temp: Temp, cg: *CodeGen) void {
+                switch (kind) {
+                    else => {},
+                    inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, cg),
+                }
             }
         };
 
-        fn create(spec: TempSpec, s: *Select) InnerError!struct { Temp, bool } {
+        fn create(spec: TempSpec, s: *const Select) InnerError!struct { Temp, bool } {
             const cg = s.cg;
             const pt = cg.pt;
             return switch (spec.kind) {
-                .unused => unreachable,
+                .unused => .{ undefined, false },
                 .any => .{ try cg.tempAlloc(spec.type), true },
                 .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true },
                 .ref => |ref| .{ ref.tempOf(s), false },
@@ -90882,7 +92551,7 @@ const Select = struct {
                     .register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index],
                 }), true },
                 .ret_gpr_pair => |ret_spec| .{ try cg.tempInit(spec.type, .{
-                    .register_pair = abi.getCAbiIntParamRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
+                    .register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
                 }), true },
                 .rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true },
                 .rc_pair => |rc| .{ try cg.tempAllocRegPair(spec.type, regSetForRegClass(rc)), true },
@@ -90907,6 +92576,7 @@ const Select = struct {
                     return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true };
                 },
                 .mem => .{ try cg.tempAllocMem(spec.type), true },
+                .mem_of_type => |ref| .{ try cg.tempAllocMem(ref.typeOf(s)), true },
                 .smin_mem, .smax_mem, .umin_mem, .umax_mem, .@"0x1p63_mem" => |const_spec| {
                     const zcu = pt.zcu;
                     const ip = &zcu.intern_pool;
@@ -91922,15 +93592,10 @@ fn select(
 
             @memcpy(s_src_temps[0..src_temps.len], src_temps);
             std.mem.swap(Temp, &s_src_temps[pattern.commute[0]], &s_src_temps[pattern.commute[1]]);
-            for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| {
-                if (dst_kind.pass() != 1) continue;
-                dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s);
-            }
-            var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
-            for (1..3) |pass| for (s_tmp_temps, &tmp_owned, case.extra_temps) |*temp, *owned, spec| {
-                if (spec.kind.pass() != pass) continue;
-                temp.*, owned.* = try spec.create(&s);
-            };
+            var dst_locks: [s_dst_temps.len][2]?RegisterLock = @splat(@splat(null));
+            for (dst_locks[0..dst_temps.len], case.dst_temps[0..dst_temps.len]) |*dst_lock, dst_kind| dst_lock.* = try dst_kind.lock(cg);
+            var tmp_locks: [s_tmp_temps.len][2]?RegisterLock = @splat(@splat(null));
+            for (&tmp_locks, case.extra_temps) |*tmp_lock, tmp_spec| tmp_lock.* = try tmp_spec.kind.lock(cg);
 
             while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| {
                 if (try src_pattern.convert(src_temp, cg)) break;
@@ -91940,10 +93605,9 @@ fn select(
 
             if (case.clobbers.eflags) try cg.spillEflagsIfOccupied();
 
-            for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| {
-                if (dst_kind.pass() != 2) continue;
-                dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s);
-            }
+            var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
+            for (s_tmp_temps, &tmp_owned, case.extra_temps) |*temp, *owned, tmp_spec| temp.*, owned.* = try tmp_spec.create(&s);
+            for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, tmp_kind| dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = tmp_kind }, &s);
             @memcpy(s_dst_temps[0..dst_temps.len], dst_temps);
 
             switch (case.each) {
@@ -91954,6 +93618,8 @@ fn select(
             }
             assert(s.top == 0);
 
+            for (tmp_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
+            for (dst_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
             caller_preserved: {
                 const cc = switch (case.clobbers.caller_preserved) {
                     .none => break :caller_preserved,
@@ -91972,7 +93638,7 @@ fn select(
                     },
                 }
             }
-            for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, dst_kind| dst_kind.finish(dst_temp, &s);
+            for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, tmp_kind| tmp_kind.finish(dst_temp, cg);
             for (tmp_owned, s_tmp_temps) |owned, temp| if (owned) try temp.die(cg);
             return;
         }