Commit 8c48376d64391aba5edd0e2c8219537554cf2819 | zig

author	Jacob Young <jacobly@ziglang.org> 2025-02-13 17:28:33-05:00
committer	Jacob Young <jacobly@ziglang.org> 2025-02-15 03:45:21-05:00
log	8c48376d64391aba5edd0e2c8219537554cf2819
tree	58548c76f15cae07fbadfef5faac8ac10b0366af
parent	9f121ec8fb07f20413584068105bee3430be3e70

x86_64: rewrite scalar and vector int `@divTrunc`

7 files changed, 2864 insertions(+), 1138 deletions(-)

lib
- compiler_rt.zig
- compiler_rt
  - divmodei4.zig
  - udivmodei4.zig
src
- arch
  - x86_64
    CodeGen.zig
test
- behavior
  - x86_64
    math.zig
- cases
  - safety
    integer division by zero - vectors.zig
    signed integer division overflow - vectors.zig

lib/compiler_rt.zig+1

...	...	@@ -230,6 +230,7 @@ comptime {
230	230	_ = @import("compiler_rt/trunc.zig");
231	231
232	232	// BigInt. Alphabetically sorted.
	233	_ = @import("compiler_rt/divmodei4.zig");
233	234	_ = @import("compiler_rt/udivmodei4.zig");
234	235	_ = @import("compiler_rt/udivmodti4.zig");
235	236

lib/compiler_rt/divmodei4.zig created+50

...	...	@@ -0,0 +1,50 @@
	1	const std = @import("std");
	2	const builtin = @import("builtin");
	3	const common = @import("common.zig");
	4	const udivmod = @import("udivmodei4.zig").divmod;
	5
	6	comptime {
	7	@export(&__divei4, .{ .name = "__divei4", .linkage = common.linkage, .visibility = common.visibility });
	8	@export(&__modei4, .{ .name = "__modei4", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	const endian = builtin.cpu.arch.endian();
	12
	13	inline fn limb(x: []u32, i: usize) *u32 {
	14	return if (endian == .little) &x[i] else &x[x.len - 1 - i];
	15	}
	16
	17	inline fn neg(x: []u32) void {
	18	var ov: u1 = 1;
	19	for (0..x.len) \|limb_index\| {
	20	const l = limb(x, limb_index);
	21	l., ov = @addWithOverflow(~l., ov);
	22	}
	23	}
	24
	25	/// Mutates the arguments!
	26	fn divmod(q: ?[]u32, r: ?[]u32, u: []u32, v: []u32) !void {
	27	const u_sign: i32 = @bitCast(u[u.len - 1]);
	28	const v_sign: i32 = @bitCast(v[v.len - 1]);
	29	if (u_sign < 0) neg(u);
	30	if (v_sign < 0) neg(v);
	31	try @call(.always_inline, udivmod, .{ q, r, u, v });
	32	if (q) \|x\| if (u_sign ^ v_sign < 0) neg(x);
	33	if (r) \|x\| if (u_sign < 0) neg(x);
	34	}
	35
	36	pub fn __divei4(r_q: []u32, u_p: []u32, v_p: [*]u32, bits: usize) callconv(.C) void {
	37	@setRuntimeSafety(builtin.is_test);
	38	const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
	39	const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
	40	const q = r_q[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
	41	@call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable;
	42	}
	43
	44	pub fn __modei4(r_p: []u32, u_p: []u32, v_p: [*]u32, bits: usize) callconv(.C) void {
	45	@setRuntimeSafety(builtin.is_test);
	46	const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
	47	const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
	48	const r = r_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
	49	@call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
	50	}

lib/compiler_rt/udivmodei4.zig+2-2

...	...	@@ -27,8 +27,8 @@ inline fn limb_set(x: []u32, i: usize, v: u32) void {
27	27	}
28	28	}
29	29
30		// Uses Knuth's Algorithm D, 4.3.1, p. 272.
31		fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void {
	30	/// Uses Knuth's Algorithm D, 4.3.1, p. 272.
	31	pub fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void {
32	32	if (q) \|q_\| @memset(q_[0..], 0);
33	33	if (r) \|r_\| @memset(r_[0..], 0);
34	34

src/arch/x86_64/CodeGen.zig+2768-1102

...	...	@@ -2418,7 +2418,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2418	2418	}
2419	2419
2420	2420	fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2421		@setEvalBranchQuota(12_200);
	2421	@setEvalBranchQuota(12_300);
2422	2422	const pt = cg.pt;
2423	2423	const zcu = pt.zcu;
2424	2424	const ip = &zcu.intern_pool;
...	...	@@ -7785,1068 +7785,1726 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
7785	7785	};
7786	7786	try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
7787	7787	},
7788		.div_trunc, .div_floor => \|air_tag\| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: {
	7788	.div_trunc => \|air_tag\| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else {
7789	7789	const bin_op = air_datas[@intFromEnum(inst)].bin_op;
7790		if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag);
7791	7790	var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
7792	7791	var res: [1]Temp = undefined;
7793		cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) {
7794		else => unreachable,
7795		.div_trunc => .zero,
7796		.div_floor => .down,
7797		})) {
7798		else => unreachable,
7799		inline .zero, .down => \|direction\| comptime &.{ .{
7800		.required_features = .{ .f16c, null, null, null },
7801		.src_constraints = .{
7802		.{ .scalar_float = .{ .of = .word, .is = .word } },
7803		.{ .scalar_float = .{ .of = .word, .is = .word } },
7804		.any,
7805		},
7806		.patterns = &.{
7807		.{ .src = .{ .to_sse, .to_sse, .none } },
7808		},
7809		.extra_temps = .{
7810		.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
7811		.unused,
7812		.unused,
7813		.unused,
7814		.unused,
7815		.unused,
7816		.unused,
7817		.unused,
7818		.unused,
7819		},
7820		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
7821		.each = .{ .once = &.{
7822		.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
7823		.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
7824		.{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
7825		.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
7826		.{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
7827		.{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
7828		.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
7829		} },
7830		}, .{
7831		.required_features = .{ .sse, null, null, null },
7832		.src_constraints = .{
7833		.{ .scalar_float = .{ .of = .word, .is = .word } },
7834		.{ .scalar_float = .{ .of = .word, .is = .word } },
7835		.any,
7836		},
7837		.patterns = &.{
7838		.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
7839		},
7840		.call_frame = .{ .alignment = .@"16" },
7841		.extra_temps = .{
7842		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
7843		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
7844		else => unreachable,
7845		.zero => "__trunch",
7846		.down => "__floorh",
7847		} } } },
7848		.unused,
7849		.unused,
7850		.unused,
7851		.unused,
7852		.unused,
7853		.unused,
7854		.unused,
7855		},
7856		.dst_temps = .{ .{ .ref = .src0 }, .unused },
7857		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
7858		.each = .{ .once = &.{
7859		.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
7860		.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
7861		} },
7862		}, .{
7863		.required_features = .{ .f16c, null, null, null },
7864		.src_constraints = .{
7865		.{ .scalar_float = .{ .of = .qword, .is = .word } },
7866		.{ .scalar_float = .{ .of = .qword, .is = .word } },
7867		.any,
7868		},
7869		.patterns = &.{
7870		.{ .src = .{ .mem, .mem, .none } },
7871		.{ .src = .{ .to_sse, .mem, .none } },
7872		.{ .src = .{ .mem, .to_sse, .none } },
7873		.{ .src = .{ .to_sse, .to_sse, .none } },
7874		},
7875		.extra_temps = .{
7876		.{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
7877		.unused,
7878		.unused,
7879		.unused,
7880		.unused,
7881		.unused,
7882		.unused,
7883		.unused,
7884		.unused,
7885		},
7886		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
7887		.each = .{ .once = &.{
7888		.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
7889		.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
7890		.{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
7891		.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
7892		.{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
7893		.{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
7894		.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
7895		} },
7896		}, .{
7897		.required_features = .{ .f16c, null, null, null },
7898		.src_constraints = .{
7899		.{ .scalar_float = .{ .of = .xword, .is = .word } },
7900		.{ .scalar_float = .{ .of = .xword, .is = .word } },
7901		.any,
7902		},
7903		.patterns = &.{
7904		.{ .src = .{ .mem, .mem, .none } },
7905		.{ .src = .{ .to_sse, .mem, .none } },
7906		.{ .src = .{ .mem, .to_sse, .none } },
7907		.{ .src = .{ .to_sse, .to_sse, .none } },
7908		},
7909		.extra_temps = .{
7910		.{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
7911		.unused,
7912		.unused,
7913		.unused,
7914		.unused,
7915		.unused,
7916		.unused,
7917		.unused,
7918		.unused,
7919		},
7920		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
7921		.each = .{ .once = &.{
7922		.{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
7923		.{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
7924		.{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
7925		.{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
7926		.{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
7927		.{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
7928		.{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
7929		} },
7930		}, .{
7931		.required_features = .{ .f16c, null, null, null },
7932		.src_constraints = .{
7933		.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
7934		.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
7935		.any,
7936		},
7937		.patterns = &.{
7938		.{ .src = .{ .to_mem, .to_mem, .none } },
7939		},
7940		.extra_temps = .{
7941		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
7942		.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
7943		.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
7944		.unused,
7945		.unused,
7946		.unused,
7947		.unused,
7948		.unused,
7949		.unused,
7950		},
7951		.dst_temps = .{ .mem, .unused },
7952		.clobbers = .{ .eflags = true },
7953		.each = .{ .once = &.{
7954		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
7955		.{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
7956		.{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
7957		.{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
7958		.{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
7959		.{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
7960		.{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
7961		.{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
7962		.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
7963		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
7964		} },
7965		}, .{
7966		.required_features = .{ .avx, null, null, null },
7967		.src_constraints = .{
7968		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
7969		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
7970		.any,
7971		},
7972		.patterns = &.{
7973		.{ .src = .{ .to_mem, .to_mem, .none } },
7974		},
7975		.call_frame = .{ .alignment = .@"16" },
7976		.extra_temps = .{
7977		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
7978		.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
7979		.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
7980		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
7981		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
7982		else => unreachable,
7983		.zero => "__trunch",
7984		.down => "__floorh",
7985		} } } },
7986		.unused,
7987		.unused,
7988		.unused,
7989		.unused,
7990		},
7991		.dst_temps = .{ .mem, .unused },
7992		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
7993		.each = .{ .once = &.{
7994		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
7995		.{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
7996		.{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
7997		.{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
7998		.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
7999		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8000		.{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
8001		.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8002		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8003		} },
8004		}, .{
8005		.required_features = .{ .sse4_1, null, null, null },
8006		.src_constraints = .{
8007		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8008		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8009		.any,
8010		},
8011		.patterns = &.{
8012		.{ .src = .{ .to_mem, .to_mem, .none } },
8013		},
8014		.call_frame = .{ .alignment = .@"16" },
8015		.extra_temps = .{
8016		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8017		.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8018		.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8019		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8020		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8021		else => unreachable,
8022		.zero => "__trunch",
8023		.down => "__floorh",
8024		} } } },
8025		.unused,
8026		.unused,
8027		.unused,
8028		.unused,
8029		},
8030		.dst_temps = .{ .mem, .unused },
8031		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8032		.each = .{ .once = &.{
8033		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8034		.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
8035		.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
8036		.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8037		.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8038		.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8039		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8040		.{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
8041		.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8042		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8043		} },
8044		}, .{
8045		.required_features = .{ .sse2, null, null, null },
8046		.src_constraints = .{
8047		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8048		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8049		.any,
8050		},
8051		.patterns = &.{
8052		.{ .src = .{ .to_mem, .to_mem, .none } },
8053		},
8054		.call_frame = .{ .alignment = .@"16" },
8055		.extra_temps = .{
8056		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8057		.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8058		.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8059		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8060		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8061		else => unreachable,
8062		.zero => "__trunch",
8063		.down => "__floorh",
8064		} } } },
8065		.{ .type = .f16, .kind = .{ .reg = .ax } },
8066		.unused,
8067		.unused,
8068		.unused,
8069		},
8070		.dst_temps = .{ .mem, .unused },
8071		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8072		.each = .{ .once = &.{
8073		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8074		.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
8075		.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
8076		.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8077		.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8078		.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8079		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8080		.{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
8081		.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
8082		.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8083		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8084		} },
8085		}, .{
8086		.required_features = .{ .sse, null, null, null },
8087		.src_constraints = .{
8088		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8089		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8090		.any,
8091		},
8092		.patterns = &.{
8093		.{ .src = .{ .to_mem, .to_mem, .none } },
8094		},
8095		.call_frame = .{ .alignment = .@"16" },
8096		.extra_temps = .{
8097		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8098		.{ .type = .f16, .kind = .{ .reg = .ax } },
8099		.{ .type = .f32, .kind = .mem },
8100		.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8101		.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8102		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8103		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8104		else => unreachable,
8105		.zero => "__trunch",
8106		.down => "__floorh",
8107		} } } },
8108		.unused,
8109		.unused,
8110		},
8111		.dst_temps = .{ .mem, .unused },
8112		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8113		.each = .{ .once = &.{
8114		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8115		.{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
8116		.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
8117		.{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
8118		.{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
8119		.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
8120		.{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
8121		.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
8122		.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
8123		.{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
8124		.{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
8125		.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
8126		.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8127		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	7792	cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
	7793	.src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
	7794	.patterns = &.{
	7795	.{ .src = .{ .mem, .mem, .none } },
	7796	.{ .src = .{ .to_gpr, .mem, .none } },
	7797	.{ .src = .{ .mem, .to_gpr, .none } },
	7798	.{ .src = .{ .to_gpr, .to_gpr, .none } },
	7799	},
	7800	.dst_temps = .{ .{ .reg = .al }, .unused },
	7801	.clobbers = .{ .eflags = true },
	7802	.each = .{ .once = &.{
	7803	.{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
	7804	.{ ._, .i_, .div, .src1b, ._, ._, ._ },
	7805	} },
	7806	}, .{
	7807	.src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
	7808	.patterns = &.{
	7809	.{ .src = .{ .mem, .mem, .none } },
	7810	.{ .src = .{ .to_gpr, .mem, .none } },
	7811	.{ .src = .{ .mem, .to_gpr, .none } },
	7812	.{ .src = .{ .to_gpr, .to_gpr, .none } },
	7813	},
	7814	.dst_temps = .{ .{ .reg = .al }, .unused },
	7815	.clobbers = .{ .eflags = true },
	7816	.each = .{ .once = &.{
	7817	.{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
	7818	.{ ._, ._, .div, .src1b, ._, ._, ._ },
	7819	} },
	7820	}, .{
	7821	.src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
	7822	.patterns = &.{
	7823	.{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
	7824	.{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
	7825	},
	7826	.extra_temps = .{
	7827	.{ .type = .i16, .kind = .{ .reg = .dx } },
	7828	.unused,
	7829	.unused,
	7830	.unused,
	7831	.unused,
	7832	.unused,
	7833	.unused,
	7834	.unused,
	7835	.unused,
	7836	},
	7837	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	7838	.clobbers = .{ .eflags = true },
	7839	.each = .{ .once = &.{
	7840	.{ ._, ._, .cwd, ._, ._, ._, ._ },
	7841	.{ ._, .i_, .div, .src1w, ._, ._, ._ },
	7842	} },
	7843	}, .{
	7844	.src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
	7845	.patterns = &.{
	7846	.{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
	7847	.{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
	7848	},
	7849	.extra_temps = .{
	7850	.{ .type = .u16, .kind = .{ .reg = .dx } },
	7851	.unused,
	7852	.unused,
	7853	.unused,
	7854	.unused,
	7855	.unused,
	7856	.unused,
	7857	.unused,
	7858	.unused,
	7859	},
	7860	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	7861	.clobbers = .{ .eflags = true },
	7862	.each = .{ .once = &.{
	7863	.{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
	7864	.{ ._, ._, .div, .src1w, ._, ._, ._ },
	7865	} },
	7866	}, .{
	7867	.src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
	7868	.patterns = &.{
	7869	.{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
	7870	.{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
	7871	},
	7872	.extra_temps = .{
	7873	.{ .type = .i32, .kind = .{ .reg = .edx } },
	7874	.unused,
	7875	.unused,
	7876	.unused,
	7877	.unused,
	7878	.unused,
	7879	.unused,
	7880	.unused,
	7881	.unused,
	7882	},
	7883	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	7884	.clobbers = .{ .eflags = true },
	7885	.each = .{ .once = &.{
	7886	.{ ._, ._, .cdq, ._, ._, ._, ._ },
	7887	.{ ._, .i_, .div, .src1d, ._, ._, ._ },
	7888	} },
	7889	}, .{
	7890	.src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
	7891	.patterns = &.{
	7892	.{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
	7893	.{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
	7894	},
	7895	.extra_temps = .{
	7896	.{ .type = .u32, .kind = .{ .reg = .edx } },
	7897	.unused,
	7898	.unused,
	7899	.unused,
	7900	.unused,
	7901	.unused,
	7902	.unused,
	7903	.unused,
	7904	.unused,
	7905	},
	7906	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	7907	.clobbers = .{ .eflags = true },
	7908	.each = .{ .once = &.{
	7909	.{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
	7910	.{ ._, ._, .div, .src1d, ._, ._, ._ },
	7911	} },
	7912	}, .{
	7913	.required_features = .{ .@"64bit", null, null, null },
	7914	.src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
	7915	.patterns = &.{
	7916	.{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
	7917	.{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
	7918	},
	7919	.extra_temps = .{
	7920	.{ .type = .i64, .kind = .{ .reg = .rdx } },
	7921	.unused,
	7922	.unused,
	7923	.unused,
	7924	.unused,
	7925	.unused,
	7926	.unused,
	7927	.unused,
	7928	.unused,
	7929	},
	7930	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	7931	.clobbers = .{ .eflags = true },
	7932	.each = .{ .once = &.{
	7933	.{ ._, ._, .cqo, ._, ._, ._, ._ },
	7934	.{ ._, .i_, .div, .src1q, ._, ._, ._ },
	7935	} },
	7936	}, .{
	7937	.required_features = .{ .@"64bit", null, null, null },
	7938	.src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
	7939	.patterns = &.{
	7940	.{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
	7941	.{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
	7942	},
	7943	.extra_temps = .{
	7944	.{ .type = .u64, .kind = .{ .reg = .rdx } },
	7945	.unused,
	7946	.unused,
	7947	.unused,
	7948	.unused,
	7949	.unused,
	7950	.unused,
	7951	.unused,
	7952	.unused,
	7953	},
	7954	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	7955	.clobbers = .{ .eflags = true },
	7956	.each = .{ .once = &.{
	7957	.{ ._, ._, .xor, .tmp0q, .tmp0q, ._, ._ },
	7958	.{ ._, ._, .div, .src1q, ._, ._, ._ },
	7959	} },
	7960	}, .{
	7961	.required_features = .{ .@"64bit", null, null, null },
	7962	.src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
	7963	.patterns = &.{
	7964	.{ .src = .{
	7965	.{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } },
	7966	.{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } },
	7967	.none,
8128	7968	} },
8129		}, .{
8130		.required_features = .{ .avx, null, null, null },
8131		.src_constraints = .{
8132		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
8133		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
8134		.any,
8135		},
8136		.patterns = &.{
8137		.{ .src = .{ .to_sse, .mem, .none } },
8138		.{ .src = .{ .to_sse, .to_sse, .none } },
8139		},
8140		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8141		.each = .{ .once = &.{
8142		.{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
8143		.{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
8144		} },
8145		}, .{
8146		.required_features = .{ .sse4_1, null, null, null },
8147		.src_constraints = .{
8148		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
8149		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
8150		.any,
8151		},
8152		.patterns = &.{
8153		.{ .src = .{ .to_mut_sse, .mem, .none } },
8154		.{ .src = .{ .to_mut_sse, .to_sse, .none } },
8155		},
8156		.dst_temps = .{ .{ .ref = .src0 }, .unused },
8157		.each = .{ .once = &.{
8158		.{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
8159		.{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8160		} },
8161		}, .{
8162		.required_features = .{ .sse, null, null, null },
8163		.src_constraints = .{
8164		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
8165		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
8166		.any,
8167		},
8168		.patterns = &.{
8169		.{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
8170		},
8171		.call_frame = .{ .alignment = .@"16" },
8172		.extra_temps = .{
8173		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8174		else => unreachable,
8175		.zero => "truncf",
8176		.down => "floorf",
8177		} } } },
8178		.unused,
8179		.unused,
8180		.unused,
8181		.unused,
8182		.unused,
8183		.unused,
8184		.unused,
8185		.unused,
8186		},
8187		.dst_temps = .{ .{ .ref = .src0 }, .unused },
8188		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8189		.each = .{ .once = &.{
8190		.{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
8191		.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8192		} },
8193		}, .{
8194		.required_features = .{ .avx, null, null, null },
8195		.src_constraints = .{
8196		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
8197		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
8198		.any,
8199		},
8200		.patterns = &.{
8201		.{ .src = .{ .to_sse, .mem, .none } },
8202		.{ .src = .{ .to_sse, .to_sse, .none } },
8203		},
8204		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8205		.each = .{ .once = &.{
8206		.{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
8207		.{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8208		} },
8209		}, .{
8210		.required_features = .{ .sse4_1, null, null, null },
8211		.src_constraints = .{
8212		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
8213		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
8214		.any,
8215		},
8216		.patterns = &.{
8217		.{ .src = .{ .to_mut_sse, .mem, .none } },
8218		.{ .src = .{ .to_mut_sse, .to_sse, .none } },
8219		},
8220		.dst_temps = .{ .{ .ref = .src0 }, .unused },
8221		.each = .{ .once = &.{
8222		.{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
8223		.{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8224		} },
8225		}, .{
8226		.required_features = .{ .sse, null, null, null },
8227		.src_constraints = .{
8228		.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
8229		.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
8230		.any,
8231		},
8232		.patterns = &.{
8233		.{ .src = .{ .to_mem, .to_mem, .none } },
8234		},
8235		.call_frame = .{ .alignment = .@"16" },
8236		.extra_temps = .{
8237		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8238		.{ .type = .f32, .kind = .{ .reg = .xmm0 } },
8239		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8240		else => unreachable,
8241		.zero => "truncf",
8242		.down => "floorf",
8243		} } } },
8244		.unused,
8245		.unused,
8246		.unused,
8247		.unused,
8248		.unused,
8249		.unused,
8250		},
8251		.dst_temps = .{ .mem, .unused },
8252		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8253		.each = .{ .once = &.{
8254		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8255		.{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
8256		.{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
8257		.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
8258		.{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8259		.{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
8260		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8261		} },
8262		}, .{
8263		.required_features = .{ .avx, null, null, null },
8264		.src_constraints = .{
8265		.{ .scalar_float = .{ .of = .yword, .is = .dword } },
8266		.{ .scalar_float = .{ .of = .yword, .is = .dword } },
8267		.any,
8268		},
8269		.patterns = &.{
8270		.{ .src = .{ .to_sse, .mem, .none } },
8271		.{ .src = .{ .to_sse, .to_sse, .none } },
8272		},
8273		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8274		.each = .{ .once = &.{
8275		.{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
8276		.{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8277		} },
8278		}, .{
8279		.required_features = .{ .avx, null, null, null },
8280		.src_constraints = .{
8281		.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
8282		.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
8283		.any,
8284		},
8285		.patterns = &.{
8286		.{ .src = .{ .to_mem, .to_mem, .none } },
8287		},
8288		.extra_temps = .{
8289		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8290		.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
8291		.unused,
8292		.unused,
8293		.unused,
8294		.unused,
8295		.unused,
8296		.unused,
8297		.unused,
8298		},
8299		.dst_temps = .{ .mem, .unused },
8300		.clobbers = .{ .eflags = true },
8301		.each = .{ .once = &.{
8302		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8303		.{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
8304		.{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
8305		.{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8306		.{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
8307		.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
8308		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8309		} },
8310		}, .{
8311		.required_features = .{ .sse4_1, null, null, null },
8312		.src_constraints = .{
8313		.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
8314		.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
8315		.any,
8316		},
8317		.patterns = &.{
8318		.{ .src = .{ .to_mem, .to_mem, .none } },
8319		},
8320		.extra_temps = .{
8321		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8322		.{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
8323		.unused,
8324		.unused,
8325		.unused,
8326		.unused,
8327		.unused,
8328		.unused,
8329		.unused,
8330		},
8331		.dst_temps = .{ .mem, .unused },
8332		.clobbers = .{ .eflags = true },
8333		.each = .{ .once = &.{
8334		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8335		.{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8336		.{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8337		.{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8338		.{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8339		.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8340		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8341		} },
8342		}, .{
8343		.required_features = .{ .avx, null, null, null },
8344		.src_constraints = .{
8345		.{ .scalar_float = .{ .of = .qword, .is = .qword } },
8346		.{ .scalar_float = .{ .of = .qword, .is = .qword } },
8347		.any,
8348		},
8349		.patterns = &.{
8350		.{ .src = .{ .to_sse, .mem, .none } },
8351		.{ .src = .{ .to_sse, .to_sse, .none } },
8352		},
8353		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8354		.each = .{ .once = &.{
8355		.{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
8356		.{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }) },
8357		} },
8358		}, .{
8359		.required_features = .{ .sse4_1, null, null, null },
8360		.src_constraints = .{
8361		.{ .scalar_float = .{ .of = .qword, .is = .qword } },
8362		.{ .scalar_float = .{ .of = .qword, .is = .qword } },
8363		.any,
8364		},
8365		.patterns = &.{
8366		.{ .src = .{ .to_mut_sse, .mem, .none } },
8367		.{ .src = .{ .to_mut_sse, .to_sse, .none } },
8368		},
8369		.dst_temps = .{ .{ .ref = .src0 }, .unused },
8370		.each = .{ .once = &.{
8371		.{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
8372		.{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8373		} },
8374		}, .{
8375		.required_features = .{ .sse2, null, null, null },
8376		.src_constraints = .{
8377		.{ .scalar_float = .{ .of = .qword, .is = .qword } },
8378		.{ .scalar_float = .{ .of = .qword, .is = .qword } },
8379		.any,
8380		},
8381		.patterns = &.{
8382		.{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
8383		},
8384		.call_frame = .{ .alignment = .@"16" },
8385		.extra_temps = .{
8386		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8387		else => unreachable,
8388		.zero => "trunc",
8389		.down => "floor",
8390		} } } },
8391		.unused,
8392		.unused,
8393		.unused,
8394		.unused,
8395		.unused,
8396		.unused,
8397		.unused,
8398		.unused,
8399		},
8400		.dst_temps = .{ .{ .ref = .src0 }, .unused },
8401		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8402		.each = .{ .once = &.{
8403		.{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
8404		.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8405		} },
8406		}, .{
8407		.required_features = .{ .sse, null, null, null },
8408		.src_constraints = .{
8409		.{ .scalar_float = .{ .of = .qword, .is = .qword } },
8410		.{ .scalar_float = .{ .of = .qword, .is = .qword } },
8411		.any,
8412		},
8413		.patterns = &.{
8414		.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
8415		},
8416		.call_frame = .{ .alignment = .@"16" },
8417		.extra_temps = .{
8418		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
8419		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8420		else => unreachable,
8421		.zero => "trunc",
8422		.down => "floor",
8423		} } } },
8424		.unused,
8425		.unused,
8426		.unused,
8427		.unused,
8428		.unused,
8429		.unused,
8430		.unused,
8431		},
8432		.dst_temps = .{ .{ .ref = .src0 }, .unused },
8433		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8434		.each = .{ .once = &.{
8435		.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8436		.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
8437		} },
8438		}, .{
8439		.required_features = .{ .avx, null, null, null },
8440		.src_constraints = .{
8441		.{ .scalar_float = .{ .of = .xword, .is = .qword } },
8442		.{ .scalar_float = .{ .of = .xword, .is = .qword } },
8443		.any,
8444		},
8445		.patterns = &.{
8446		.{ .src = .{ .to_sse, .mem, .none } },
8447		.{ .src = .{ .to_sse, .to_sse, .none } },
8448		},
8449		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8450		.each = .{ .once = &.{
8451		.{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
8452		.{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8453		} },
8454		}, .{
8455		.required_features = .{ .sse4_1, null, null, null },
8456		.src_constraints = .{
8457		.{ .scalar_float = .{ .of = .xword, .is = .qword } },
8458		.{ .scalar_float = .{ .of = .xword, .is = .qword } },
8459		.any,
8460		},
8461		.patterns = &.{
8462		.{ .src = .{ .to_mut_sse, .mem, .none } },
8463		.{ .src = .{ .to_mut_sse, .to_sse, .none } },
8464		},
8465		.dst_temps = .{ .{ .ref = .src0 }, .unused },
8466		.each = .{ .once = &.{
8467		.{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
8468		.{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8469		} },
8470		}, .{
8471		.required_features = .{ .avx, null, null, null },
8472		.src_constraints = .{
8473		.{ .scalar_float = .{ .of = .yword, .is = .qword } },
8474		.{ .scalar_float = .{ .of = .yword, .is = .qword } },
8475		.any,
8476		},
8477		.patterns = &.{
8478		.{ .src = .{ .to_sse, .mem, .none } },
8479		.{ .src = .{ .to_sse, .to_sse, .none } },
8480		},
8481		.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8482		.each = .{ .once = &.{
8483		.{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
8484		.{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8485		} },
8486		}, .{
8487		.required_features = .{ .avx, null, null, null },
8488		.src_constraints = .{
8489		.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
8490		.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
8491		.any,
8492		},
8493		.patterns = &.{
8494		.{ .src = .{ .to_mem, .to_mem, .none } },
8495		},
8496		.extra_temps = .{
8497		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8498		.{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
8499		.unused,
8500		.unused,
8501		.unused,
8502		.unused,
8503		.unused,
8504		.unused,
8505		.unused,
8506		},
8507		.dst_temps = .{ .mem, .unused },
8508		.clobbers = .{ .eflags = true },
8509		.each = .{ .once = &.{
8510		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8511		.{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
8512		.{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
8513		.{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8514		.{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
8515		.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
8516		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8517		} },
8518		}, .{
8519		.required_features = .{ .sse4_1, null, null, null },
8520		.src_constraints = .{
8521		.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
8522		.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
8523		.any,
8524		},
8525		.patterns = &.{
8526		.{ .src = .{ .to_mem, .to_mem, .none } },
8527		},
8528		.extra_temps = .{
8529		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8530		.{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
8531		.unused,
8532		.unused,
8533		.unused,
8534		.unused,
8535		.unused,
8536		.unused,
8537		.unused,
8538		},
8539		.dst_temps = .{ .mem, .unused },
8540		.clobbers = .{ .eflags = true },
8541		.each = .{ .once = &.{
8542		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8543		.{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8544		.{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8545		.{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8546		.{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8547		.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8548		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8549		} },
8550		}, .{
8551		.required_features = .{ .sse2, null, null, null },
8552		.src_constraints = .{
8553		.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
8554		.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
8555		.any,
8556		},
8557		.patterns = &.{
8558		.{ .src = .{ .to_mem, .to_mem, .none } },
8559		},
8560		.call_frame = .{ .alignment = .@"16" },
8561		.extra_temps = .{
8562		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8563		.{ .type = .f64, .kind = .{ .reg = .xmm0 } },
8564		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8565		else => unreachable,
8566		.zero => "trunc",
8567		.down => "floor",
8568		} } } },
8569		.unused,
8570		.unused,
8571		.unused,
8572		.unused,
8573		.unused,
8574		.unused,
8575		},
8576		.dst_temps = .{ .mem, .unused },
8577		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8578		.each = .{ .once = &.{
8579		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8580		.{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
8581		.{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
8582		.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
8583		.{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8584		.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
8585		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8586		} },
8587		}, .{
8588		.required_features = .{ .sse, null, null, null },
8589		.src_constraints = .{
8590		.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
8591		.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
8592		.any,
8593		},
8594		.patterns = &.{
8595		.{ .src = .{ .to_mem, .to_mem, .none } },
8596		},
8597		.call_frame = .{ .alignment = .@"16" },
8598		.extra_temps = .{
8599		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8600		.{ .type = .f64, .kind = .{ .reg = .xmm0 } },
8601		.{ .type = .f64, .kind = .{ .reg = .xmm1 } },
8602		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
8603		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8604		else => unreachable,
8605		.zero => "trunc",
8606		.down => "floor",
8607		} } } },
8608		.unused,
8609		.unused,
8610		.unused,
8611		.unused,
8612		},
8613		.dst_temps = .{ .mem, .unused },
8614		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8615		.each = .{ .once = &.{
8616		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8617		.{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
8618		.{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
8619		.{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
8620		.{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
8621		.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8622		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8623		.{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8624		.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
8625		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8626		} },
8627		}, .{
8628		.required_features = .{ .x87, null, null, null },
8629		.src_constraints = .{
8630		.{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
8631		.{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
8632		.any,
8633		},
8634		.patterns = &.{
8635		.{ .src = .{ .to_mem, .to_mem, .none } },
8636		},
8637		.call_frame = .{ .size = 16, .alignment = .@"16" },
8638		.extra_temps = .{
8639		.{ .type = .f80, .kind = .{ .reg = .st6 } },
8640		.{ .type = .f80, .kind = .{ .reg = .st7 } },
8641		.{ .type = .f80, .kind = .{ .frame = .call_frame } },
8642		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8643		else => unreachable,
8644		.zero => "__truncx",
8645		.down => "__floorx",
8646		} } } },
8647		.unused,
8648		.unused,
8649		.unused,
8650		.unused,
8651		.unused,
8652		},
8653		.dst_temps = .{ .{ .reg = .st0 }, .unused },
8654		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8655		.each = .{ .once = &.{
8656		.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
8657		.{ ._, .f_, .ld, .src1t, ._, ._, ._ },
8658		.{ ._, .f_p, .div, ._, ._, ._, ._ },
8659		.{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
8660		.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8661		} },
8662		}, .{
8663		.required_features = .{ .x87, null, null, null },
8664		.src_constraints = .{
8665		.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
8666		.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
8667		.any,
8668		},
8669		.patterns = &.{
8670		.{ .src = .{ .to_mem, .to_mem, .none } },
8671		},
8672		.call_frame = .{ .size = 16, .alignment = .@"16" },
8673		.extra_temps = .{
8674		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8675		.{ .type = .f80, .kind = .{ .reg = .st6 } },
8676		.{ .type = .f80, .kind = .{ .reg = .st7 } },
8677		.{ .type = .f80, .kind = .{ .frame = .call_frame } },
8678		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8679		else => unreachable,
8680		.zero => "__truncx",
8681		.down => "__floorx",
8682		} } } },
8683		.unused,
8684		.unused,
8685		.unused,
8686		.unused,
8687		},
8688		.dst_temps = .{ .mem, .unused },
8689		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8690		.each = .{ .once = &.{
8691		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8692		.{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
8693		.{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
8694		.{ ._, .f_p, .div, ._, ._, ._, ._ },
8695		.{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
8696		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8697		.{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
8698		.{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
8699		.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8700		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8701		} },
8702		}, .{
8703		.required_features = .{ .sse, null, null, null },
8704		.src_constraints = .{
8705		.{ .scalar_float = .{ .of = .xword, .is = .xword } },
8706		.{ .scalar_float = .{ .of = .xword, .is = .xword } },
8707		.any,
8708		},
8709		.patterns = &.{
8710		.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
8711		},
8712		.call_frame = .{ .alignment = .@"16" },
8713		.extra_temps = .{
8714		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
8715		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8716		else => unreachable,
8717		.zero => "truncq",
8718		.down => "floorq",
8719		} } } },
8720		.unused,
8721		.unused,
8722		.unused,
8723		.unused,
8724		.unused,
8725		.unused,
8726		.unused,
8727		},
8728		.dst_temps = .{ .{ .ref = .src0 }, .unused },
8729		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8730		.each = .{ .once = &.{
8731		.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8732		.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
8733		} },
8734		}, .{
8735		.required_features = .{ .avx, null, null, null },
8736		.src_constraints = .{
8737		.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8738		.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8739		.any,
8740		},
8741		.patterns = &.{
8742		.{ .src = .{ .to_mem, .to_mem, .none } },
8743		},
8744		.call_frame = .{ .alignment = .@"16" },
8745		.extra_temps = .{
8746		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8747		.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
8748		.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
8749		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
8750		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8751		else => unreachable,
8752		.zero => "truncq",
8753		.down => "floorq",
8754		} } } },
8755		.unused,
8756		.unused,
8757		.unused,
8758		.unused,
8759		},
8760		.dst_temps = .{ .mem, .unused },
8761		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8762		.each = .{ .once = &.{
8763		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8764		.{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8765		.{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8766		.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8767		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8768		.{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8769		.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8770		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8771		} },
8772		}, .{
8773		.required_features = .{ .sse2, null, null, null },
8774		.src_constraints = .{
8775		.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8776		.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8777		.any,
8778		},
8779		.patterns = &.{
8780		.{ .src = .{ .to_mem, .to_mem, .none } },
8781		},
8782		.call_frame = .{ .alignment = .@"16" },
8783		.extra_temps = .{
8784		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8785		.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
8786		.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
8787		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
8788		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8789		else => unreachable,
8790		.zero => "truncq",
8791		.down => "floorq",
8792		} } } },
8793		.unused,
8794		.unused,
8795		.unused,
8796		.unused,
8797		},
8798		.dst_temps = .{ .mem, .unused },
8799		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8800		.each = .{ .once = &.{
8801		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8802		.{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8803		.{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8804		.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8805		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8806		.{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8807		.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8808		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8809		} },
8810		}, .{
8811		.required_features = .{ .sse, null, null, null },
8812		.src_constraints = .{
8813		.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8814		.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8815		.any,
8816		},
8817		.patterns = &.{
8818		.{ .src = .{ .to_mem, .to_mem, .none } },
8819		},
8820		.call_frame = .{ .alignment = .@"16" },
8821		.extra_temps = .{
8822		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8823		.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
8824		.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
8825		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
8826		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8827		else => unreachable,
8828		.zero => "truncq",
8829		.down => "floorq",
8830		} } } },
8831		.unused,
8832		.unused,
8833		.unused,
8834		.unused,
8835		},
8836		.dst_temps = .{ .mem, .unused },
8837		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8838		.each = .{ .once = &.{
8839		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8840		.{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8841		.{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8842		.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8843		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8844		.{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8845		.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8846		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	7969	},
	7970	.call_frame = .{ .alignment = .@"16" },
	7971	.extra_temps = .{
	7972	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } },
	7973	.unused,
	7974	.unused,
	7975	.unused,
	7976	.unused,
	7977	.unused,
	7978	.unused,
	7979	.unused,
	7980	.unused,
	7981	},
	7982	.dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused },
	7983	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	7984	.each = .{ .once = &.{
	7985	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	7986	} },
	7987	}, .{
	7988	.required_features = .{ .@"64bit", null, null, null },
	7989	.src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
	7990	.patterns = &.{
	7991	.{ .src = .{
	7992	.{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } },
	7993	.{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } },
	7994	.none,
8847	7995	} },
	7996	},
	7997	.call_frame = .{ .alignment = .@"16" },
	7998	.extra_temps = .{
	7999	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } },
	8000	.unused,
	8001	.unused,
	8002	.unused,
	8003	.unused,
	8004	.unused,
	8005	.unused,
	8006	.unused,
	8007	.unused,
	8008	},
	8009	.dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused },
	8010	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8011	.each = .{ .once = &.{
	8012	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	8013	} },
	8014	}, .{
	8015	.required_features = .{ .@"64bit", null, null, null },
	8016	.src_constraints = .{
	8017	.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
	8018	.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
	8019	.any,
	8020	},
	8021	.patterns = &.{
	8022	.{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
	8023	},
	8024	.call_frame = .{ .alignment = .@"16" },
	8025	.extra_temps = .{
	8026	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
	8027	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
	8028	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
	8029	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
	8030	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } },
	8031	.unused,
	8032	.unused,
	8033	.unused,
	8034	.unused,
	8035	},
	8036	.dst_temps = .{ .mem, .unused },
	8037	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8038	.each = .{ .once = &.{
	8039	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	8040	.{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
	8041	.{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
	8042	.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
	8043	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	8044	} },
	8045	}, .{
	8046	.required_features = .{ .@"64bit", null, null, null },
	8047	.src_constraints = .{
	8048	.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
	8049	.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
	8050	.any,
	8051	},
	8052	.patterns = &.{
	8053	.{ .src = .{ .to_mem, .to_mem, .none } },
	8054	},
	8055	.call_frame = .{ .alignment = .@"16" },
	8056	.extra_temps = .{
	8057	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
	8058	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
	8059	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
	8060	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
	8061	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } },
	8062	.unused,
	8063	.unused,
	8064	.unused,
	8065	.unused,
	8066	},
	8067	.dst_temps = .{ .mem, .unused },
	8068	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8069	.each = .{ .once = &.{
	8070	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	8071	.{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
	8072	.{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
	8073	.{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
	8074	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	8075	} },
	8076	}, .{
	8077	.required_features = .{ .slow_incdec, null, null, null },
	8078	.src_constraints = .{
	8079	.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
	8080	.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
	8081	.any,
	8082	},
	8083	.patterns = &.{
	8084	.{ .src = .{ .to_mem, .to_mem, .none } },
	8085	},
	8086	.extra_temps = .{
	8087	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8088	.{ .type = .i8, .kind = .{ .reg = .al } },
	8089	.unused,
	8090	.unused,
	8091	.unused,
	8092	.unused,
	8093	.unused,
	8094	.unused,
	8095	.unused,
	8096	},
	8097	.dst_temps = .{ .mem, .unused },
	8098	.clobbers = .{ .eflags = true },
	8099	.each = .{ .once = &.{
	8100	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8101	.{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
	8102	.{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8103	.{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
	8104	.{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
	8105	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8106	} },
	8107	}, .{
	8108	.src_constraints = .{
	8109	.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
	8110	.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
	8111	.any,
	8112	},
	8113	.patterns = &.{
	8114	.{ .src = .{ .to_mem, .to_mem, .none } },
	8115	},
	8116	.extra_temps = .{
	8117	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8118	.{ .type = .i8, .kind = .{ .reg = .al } },
	8119	.unused,
	8120	.unused,
	8121	.unused,
	8122	.unused,
	8123	.unused,
	8124	.unused,
	8125	.unused,
	8126	},
	8127	.dst_temps = .{ .mem, .unused },
	8128	.clobbers = .{ .eflags = true },
	8129	.each = .{ .once = &.{
	8130	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8131	.{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
	8132	.{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8133	.{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
	8134	.{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
	8135	.{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
	8136	} },
	8137	}, .{
	8138	.required_features = .{ .slow_incdec, null, null, null },
	8139	.src_constraints = .{
	8140	.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
	8141	.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
	8142	.any,
	8143	},
	8144	.patterns = &.{
	8145	.{ .src = .{ .to_mem, .to_mem, .none } },
	8146	},
	8147	.extra_temps = .{
	8148	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8149	.{ .type = .u8, .kind = .{ .reg = .al } },
	8150	.unused,
	8151	.unused,
	8152	.unused,
	8153	.unused,
	8154	.unused,
	8155	.unused,
	8156	.unused,
	8157	},
	8158	.dst_temps = .{ .mem, .unused },
	8159	.clobbers = .{ .eflags = true },
	8160	.each = .{ .once = &.{
	8161	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8162	.{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
	8163	.{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8164	.{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
	8165	.{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
	8166	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8167	} },
	8168	}, .{
	8169	.src_constraints = .{
	8170	.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
	8171	.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
	8172	.any,
	8173	},
	8174	.patterns = &.{
	8175	.{ .src = .{ .to_mem, .to_mem, .none } },
	8176	},
	8177	.extra_temps = .{
	8178	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8179	.{ .type = .u8, .kind = .{ .reg = .al } },
	8180	.unused,
	8181	.unused,
	8182	.unused,
	8183	.unused,
	8184	.unused,
	8185	.unused,
	8186	.unused,
	8187	},
	8188	.dst_temps = .{ .mem, .unused },
	8189	.clobbers = .{ .eflags = true },
	8190	.each = .{ .once = &.{
	8191	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8192	.{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
	8193	.{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8194	.{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
	8195	.{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
	8196	.{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
	8197	} },
	8198	}, .{
	8199	.src_constraints = .{
	8200	.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
	8201	.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
	8202	.any,
	8203	},
	8204	.patterns = &.{
	8205	.{ .src = .{ .to_mem, .to_mem, .none } },
	8206	},
	8207	.extra_temps = .{
	8208	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8209	.{ .type = .i16, .kind = .{ .reg = .ax } },
	8210	.{ .type = .i16, .kind = .{ .reg = .dx } },
	8211	.unused,
	8212	.unused,
	8213	.unused,
	8214	.unused,
	8215	.unused,
	8216	.unused,
	8217	},
	8218	.dst_temps = .{ .mem, .unused },
	8219	.clobbers = .{ .eflags = true },
	8220	.each = .{ .once = &.{
	8221	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8222	.{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
	8223	.{ ._, ._, .cwd, ._, ._, ._, ._ },
	8224	.{ ._, .i_, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8225	.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
	8226	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	8227	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8228	} },
	8229	}, .{
	8230	.src_constraints = .{
	8231	.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
	8232	.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
	8233	.any,
	8234	},
	8235	.patterns = &.{
	8236	.{ .src = .{ .to_mem, .to_mem, .none } },
	8237	},
	8238	.extra_temps = .{
	8239	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8240	.{ .type = .u16, .kind = .{ .reg = .ax } },
	8241	.{ .type = .u16, .kind = .{ .reg = .dx } },
	8242	.unused,
	8243	.unused,
	8244	.unused,
	8245	.unused,
	8246	.unused,
	8247	.unused,
	8248	},
	8249	.dst_temps = .{ .mem, .unused },
	8250	.clobbers = .{ .eflags = true },
	8251	.each = .{ .once = &.{
	8252	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8253	.{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
	8254	.{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
	8255	.{ ._, ._, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8256	.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
	8257	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	8258	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8259	} },
	8260	}, .{
	8261	.src_constraints = .{
	8262	.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
	8263	.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
	8264	.any,
	8265	},
	8266	.patterns = &.{
	8267	.{ .src = .{ .to_mem, .to_mem, .none } },
	8268	},
	8269	.extra_temps = .{
	8270	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8271	.{ .type = .i32, .kind = .{ .reg = .eax } },
	8272	.{ .type = .i32, .kind = .{ .reg = .edx } },
	8273	.unused,
	8274	.unused,
	8275	.unused,
	8276	.unused,
	8277	.unused,
	8278	.unused,
	8279	},
	8280	.dst_temps = .{ .mem, .unused },
	8281	.clobbers = .{ .eflags = true },
	8282	.each = .{ .once = &.{
	8283	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8284	.{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
	8285	.{ ._, ._, .cdq, ._, ._, ._, ._ },
	8286	.{ ._, .i_, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8287	.{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
	8288	.{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
	8289	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8290	} },
	8291	}, .{
	8292	.src_constraints = .{
	8293	.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
	8294	.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
	8295	.any,
	8296	},
	8297	.patterns = &.{
	8298	.{ .src = .{ .to_mem, .to_mem, .none } },
	8299	},
	8300	.extra_temps = .{
	8301	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8302	.{ .type = .u32, .kind = .{ .reg = .eax } },
	8303	.{ .type = .u32, .kind = .{ .reg = .edx } },
	8304	.unused,
	8305	.unused,
	8306	.unused,
	8307	.unused,
	8308	.unused,
	8309	.unused,
	8310	},
	8311	.dst_temps = .{ .mem, .unused },
	8312	.clobbers = .{ .eflags = true },
	8313	.each = .{ .once = &.{
	8314	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8315	.{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
	8316	.{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
	8317	.{ ._, ._, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8318	.{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
	8319	.{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
	8320	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8321	} },
	8322	}, .{
	8323	.required_features = .{ .@"64bit", null, null, null },
	8324	.src_constraints = .{
	8325	.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
	8326	.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
	8327	.any,
	8328	},
	8329	.patterns = &.{
	8330	.{ .src = .{ .to_mem, .to_mem, .none } },
	8331	},
	8332	.extra_temps = .{
	8333	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8334	.{ .type = .i64, .kind = .{ .reg = .rax } },
	8335	.{ .type = .i64, .kind = .{ .reg = .rdx } },
	8336	.unused,
	8337	.unused,
	8338	.unused,
	8339	.unused,
	8340	.unused,
	8341	.unused,
	8342	},
	8343	.dst_temps = .{ .mem, .unused },
	8344	.clobbers = .{ .eflags = true },
	8345	.each = .{ .once = &.{
	8346	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8347	.{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
	8348	.{ ._, ._, .cqo, ._, ._, ._, ._ },
	8349	.{ ._, .i_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8350	.{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
	8351	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
	8352	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8353	} },
	8354	}, .{
	8355	.required_features = .{ .@"64bit", null, null, null },
	8356	.src_constraints = .{
	8357	.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
	8358	.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
	8359	.any,
	8360	},
	8361	.patterns = &.{
	8362	.{ .src = .{ .to_mem, .to_mem, .none } },
	8363	},
	8364	.extra_temps = .{
	8365	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8366	.{ .type = .u64, .kind = .{ .reg = .rax } },
	8367	.{ .type = .u64, .kind = .{ .reg = .rdx } },
	8368	.unused,
	8369	.unused,
	8370	.unused,
	8371	.unused,
	8372	.unused,
	8373	.unused,
	8374	},
	8375	.dst_temps = .{ .mem, .unused },
	8376	.clobbers = .{ .eflags = true },
	8377	.each = .{ .once = &.{
	8378	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8379	.{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
	8380	.{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
	8381	.{ ._, ._, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
	8382	.{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
	8383	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
	8384	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8385	} },
	8386	}, .{
	8387	.required_features = .{ .@"64bit", null, null, null },
	8388	.src_constraints = .{
	8389	.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
	8390	.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
	8391	.any,
	8392	},
	8393	.patterns = &.{
	8394	.{ .src = .{ .to_mem, .to_mem, .none } },
	8395	},
	8396	.call_frame = .{ .alignment = .@"16" },
	8397	.extra_temps = .{
	8398	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8399	.{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
	8400	.{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
	8401	.{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
	8402	.{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
	8403	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } },
	8404	.{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } },
	8405	.unused,
	8406	.unused,
	8407	},
	8408	.dst_temps = .{ .mem, .unused },
	8409	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8410	.each = .{ .once = &.{
	8411	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8412	.{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
	8413	.{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
	8414	.{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
	8415	.{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
	8416	.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
	8417	.{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
	8418	.{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
	8419	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	8420	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8421	} },
	8422	}, .{
	8423	.required_features = .{ .@"64bit", null, null, null },
	8424	.src_constraints = .{
	8425	.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
	8426	.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
	8427	.any,
	8428	},
	8429	.patterns = &.{
	8430	.{ .src = .{ .to_mem, .to_mem, .none } },
	8431	},
	8432	.call_frame = .{ .alignment = .@"16" },
	8433	.extra_temps = .{
	8434	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8435	.{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
	8436	.{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
	8437	.{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
	8438	.{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
	8439	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } },
	8440	.{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } },
	8441	.unused,
	8442	.unused,
	8443	},
	8444	.dst_temps = .{ .mem, .unused },
	8445	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8446	.each = .{ .once = &.{
	8447	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8448	.{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
	8449	.{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
	8450	.{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
	8451	.{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
	8452	.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
	8453	.{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
	8454	.{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
	8455	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	8456	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8457	} },
	8458	}, .{
	8459	.required_features = .{ .@"64bit", null, null, null },
	8460	.src_constraints = .{
	8461	.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
	8462	.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
	8463	.any,
	8464	},
	8465	.patterns = &.{
	8466	.{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
	8467	},
	8468	.call_frame = .{ .alignment = .@"16" },
	8469	.extra_temps = .{
	8470	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8471	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
	8472	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
	8473	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
	8474	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
	8475	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } },
	8476	.unused,
	8477	.unused,
	8478	.unused,
	8479	},
	8480	.dst_temps = .{ .mem, .unused },
	8481	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8482	.each = .{ .once = &.{
	8483	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8484	.{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
	8485	.{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
	8486	.{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
	8487	.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
	8488	.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
	8489	.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
	8490	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8491	} },
	8492	}, .{
	8493	.required_features = .{ .@"64bit", null, null, null },
	8494	.src_constraints = .{
	8495	.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
	8496	.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
	8497	.any,
	8498	},
	8499	.patterns = &.{
	8500	.{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
	8501	},
	8502	.call_frame = .{ .alignment = .@"16" },
	8503	.extra_temps = .{
	8504	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8505	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
	8506	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
	8507	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
	8508	.{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
	8509	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } },
	8510	.unused,
	8511	.unused,
	8512	.unused,
	8513	},
	8514	.dst_temps = .{ .mem, .unused },
	8515	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8516	.each = .{ .once = &.{
	8517	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8518	.{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
	8519	.{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
	8520	.{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
	8521	.{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
	8522	.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
	8523	.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
	8524	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8525	} },
	8526	}, .{
	8527	.required_features = .{ .f16c, null, null, null },
	8528	.src_constraints = .{
	8529	.{ .scalar_float = .{ .of = .word, .is = .word } },
	8530	.{ .scalar_float = .{ .of = .word, .is = .word } },
	8531	.any,
	8532	},
	8533	.patterns = &.{
	8534	.{ .src = .{ .to_sse, .to_sse, .none } },
	8535	},
	8536	.extra_temps = .{
	8537	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	8538	.unused,
	8539	.unused,
	8540	.unused,
	8541	.unused,
	8542	.unused,
	8543	.unused,
	8544	.unused,
	8545	.unused,
	8546	},
	8547	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	8548	.each = .{ .once = &.{
	8549	.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
	8550	.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
	8551	.{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
	8552	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	8553	.{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
	8554	.{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
	8555	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	8556	} },
	8557	}, .{
	8558	.required_features = .{ .sse, null, null, null },
	8559	.src_constraints = .{
	8560	.{ .scalar_float = .{ .of = .word, .is = .word } },
	8561	.{ .scalar_float = .{ .of = .word, .is = .word } },
	8562	.any,
	8563	},
	8564	.patterns = &.{
	8565	.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
	8566	},
	8567	.call_frame = .{ .alignment = .@"16" },
	8568	.extra_temps = .{
	8569	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	8570	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
	8571	.unused,
	8572	.unused,
	8573	.unused,
	8574	.unused,
	8575	.unused,
	8576	.unused,
	8577	.unused,
	8578	},
	8579	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	8580	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8581	.each = .{ .once = &.{
	8582	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	8583	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	8584	} },
	8585	}, .{
	8586	.required_features = .{ .f16c, null, null, null },
	8587	.src_constraints = .{
	8588	.{ .scalar_float = .{ .of = .qword, .is = .word } },
	8589	.{ .scalar_float = .{ .of = .qword, .is = .word } },
	8590	.any,
	8591	},
	8592	.patterns = &.{
	8593	.{ .src = .{ .mem, .mem, .none } },
	8594	.{ .src = .{ .to_sse, .mem, .none } },
	8595	.{ .src = .{ .mem, .to_sse, .none } },
	8596	.{ .src = .{ .to_sse, .to_sse, .none } },
	8597	},
	8598	.extra_temps = .{
	8599	.{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	8600	.unused,
	8601	.unused,
	8602	.unused,
	8603	.unused,
	8604	.unused,
	8605	.unused,
	8606	.unused,
	8607	.unused,
	8608	},
	8609	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	8610	.each = .{ .once = &.{
	8611	.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
	8612	.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
	8613	.{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
	8614	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	8615	.{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
	8616	.{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	8617	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	8618	} },
	8619	}, .{
	8620	.required_features = .{ .f16c, null, null, null },
	8621	.src_constraints = .{
	8622	.{ .scalar_float = .{ .of = .xword, .is = .word } },
	8623	.{ .scalar_float = .{ .of = .xword, .is = .word } },
	8624	.any,
	8625	},
	8626	.patterns = &.{
	8627	.{ .src = .{ .mem, .mem, .none } },
	8628	.{ .src = .{ .to_sse, .mem, .none } },
	8629	.{ .src = .{ .mem, .to_sse, .none } },
	8630	.{ .src = .{ .to_sse, .to_sse, .none } },
	8631	},
	8632	.extra_temps = .{
	8633	.{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	8634	.unused,
	8635	.unused,
	8636	.unused,
	8637	.unused,
	8638	.unused,
	8639	.unused,
	8640	.unused,
	8641	.unused,
	8642	},
	8643	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	8644	.each = .{ .once = &.{
	8645	.{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
	8646	.{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
	8647	.{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
	8648	.{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
	8649	.{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
	8650	.{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	8651	.{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
	8652	} },
	8653	}, .{
	8654	.required_features = .{ .f16c, null, null, null },
	8655	.src_constraints = .{
	8656	.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
	8657	.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
	8658	.any,
	8659	},
	8660	.patterns = &.{
	8661	.{ .src = .{ .to_mem, .to_mem, .none } },
	8662	},
	8663	.extra_temps = .{
	8664	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8665	.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
	8666	.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
	8667	.unused,
	8668	.unused,
	8669	.unused,
	8670	.unused,
	8671	.unused,
	8672	.unused,
	8673	},
	8674	.dst_temps = .{ .mem, .unused },
	8675	.clobbers = .{ .eflags = true },
	8676	.each = .{ .once = &.{
	8677	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8678	.{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	8679	.{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	8680	.{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
	8681	.{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
	8682	.{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
	8683	.{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	8684	.{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
	8685	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	8686	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8687	} },
	8688	}, .{
	8689	.required_features = .{ .avx, null, null, null },
	8690	.src_constraints = .{
	8691	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	8692	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	8693	.any,
	8694	},
	8695	.patterns = &.{
	8696	.{ .src = .{ .to_mem, .to_mem, .none } },
	8697	},
	8698	.call_frame = .{ .alignment = .@"16" },
	8699	.extra_temps = .{
	8700	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8701	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	8702	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	8703	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	8704	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
	8705	.unused,
	8706	.unused,
	8707	.unused,
	8708	.unused,
	8709	},
	8710	.dst_temps = .{ .mem, .unused },
	8711	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8712	.each = .{ .once = &.{
	8713	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8714	.{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
	8715	.{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
	8716	.{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
	8717	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	8718	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	8719	.{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
	8720	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	8721	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8722	} },
	8723	}, .{
	8724	.required_features = .{ .sse4_1, null, null, null },
	8725	.src_constraints = .{
	8726	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	8727	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	8728	.any,
	8729	},
	8730	.patterns = &.{
	8731	.{ .src = .{ .to_mem, .to_mem, .none } },
	8732	},
	8733	.call_frame = .{ .alignment = .@"16" },
	8734	.extra_temps = .{
	8735	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8736	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	8737	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	8738	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	8739	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
	8740	.unused,
	8741	.unused,
	8742	.unused,
	8743	.unused,
	8744	},
	8745	.dst_temps = .{ .mem, .unused },
	8746	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8747	.each = .{ .once = &.{
	8748	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8749	.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
	8750	.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
	8751	.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	8752	.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	8753	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	8754	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	8755	.{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
	8756	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	8757	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8758	} },
	8759	}, .{
	8760	.required_features = .{ .sse2, null, null, null },
	8761	.src_constraints = .{
	8762	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	8763	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	8764	.any,
	8765	},
	8766	.patterns = &.{
	8767	.{ .src = .{ .to_mem, .to_mem, .none } },
	8768	},
	8769	.call_frame = .{ .alignment = .@"16" },
	8770	.extra_temps = .{
	8771	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8772	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	8773	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	8774	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	8775	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
	8776	.{ .type = .f16, .kind = .{ .reg = .ax } },
	8777	.unused,
	8778	.unused,
	8779	.unused,
	8780	},
	8781	.dst_temps = .{ .mem, .unused },
	8782	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8783	.each = .{ .once = &.{
	8784	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8785	.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
	8786	.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
	8787	.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	8788	.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	8789	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	8790	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	8791	.{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
	8792	.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
	8793	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	8794	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8795	} },
	8796	}, .{
	8797	.required_features = .{ .sse, null, null, null },
	8798	.src_constraints = .{
	8799	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	8800	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	8801	.any,
	8802	},
	8803	.patterns = &.{
	8804	.{ .src = .{ .to_mem, .to_mem, .none } },
	8805	},
	8806	.call_frame = .{ .alignment = .@"16" },
	8807	.extra_temps = .{
	8808	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8809	.{ .type = .f16, .kind = .{ .reg = .ax } },
	8810	.{ .type = .f32, .kind = .mem },
	8811	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	8812	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	8813	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	8814	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
	8815	.unused,
	8816	.unused,
	8817	},
	8818	.dst_temps = .{ .mem, .unused },
	8819	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8820	.each = .{ .once = &.{
	8821	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8822	.{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
	8823	.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
	8824	.{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
	8825	.{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
	8826	.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
	8827	.{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
	8828	.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
	8829	.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
	8830	.{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
	8831	.{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
	8832	.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
	8833	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	8834	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8835	} },
	8836	}, .{
	8837	.required_features = .{ .avx, null, null, null },
	8838	.src_constraints = .{
	8839	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	8840	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	8841	.any,
	8842	},
	8843	.patterns = &.{
	8844	.{ .src = .{ .to_sse, .mem, .none } },
	8845	.{ .src = .{ .to_sse, .to_sse, .none } },
	8846	},
	8847	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	8848	.each = .{ .once = &.{
	8849	.{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
	8850	.{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
	8851	} },
	8852	}, .{
	8853	.required_features = .{ .sse4_1, null, null, null },
	8854	.src_constraints = .{
	8855	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	8856	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	8857	.any,
	8858	},
	8859	.patterns = &.{
	8860	.{ .src = .{ .to_mut_sse, .mem, .none } },
	8861	.{ .src = .{ .to_mut_sse, .to_sse, .none } },
	8862	},
	8863	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	8864	.each = .{ .once = &.{
	8865	.{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
	8866	.{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	8867	} },
	8868	}, .{
	8869	.required_features = .{ .sse, null, null, null },
	8870	.src_constraints = .{
	8871	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	8872	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	8873	.any,
	8874	},
	8875	.patterns = &.{
	8876	.{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
	8877	},
	8878	.call_frame = .{ .alignment = .@"16" },
	8879	.extra_temps = .{
	8880	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncf" } } },
	8881	.unused,
	8882	.unused,
	8883	.unused,
	8884	.unused,
	8885	.unused,
	8886	.unused,
	8887	.unused,
	8888	.unused,
	8889	},
	8890	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	8891	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8892	.each = .{ .once = &.{
	8893	.{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
	8894	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	8895	} },
	8896	}, .{
	8897	.required_features = .{ .avx, null, null, null },
	8898	.src_constraints = .{
	8899	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	8900	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	8901	.any,
	8902	},
	8903	.patterns = &.{
	8904	.{ .src = .{ .to_sse, .mem, .none } },
	8905	.{ .src = .{ .to_sse, .to_sse, .none } },
	8906	},
	8907	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	8908	.each = .{ .once = &.{
	8909	.{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
	8910	.{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	8911	} },
	8912	}, .{
	8913	.required_features = .{ .sse4_1, null, null, null },
	8914	.src_constraints = .{
	8915	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	8916	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	8917	.any,
	8918	},
	8919	.patterns = &.{
	8920	.{ .src = .{ .to_mut_sse, .mem, .none } },
	8921	.{ .src = .{ .to_mut_sse, .to_sse, .none } },
	8922	},
	8923	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	8924	.each = .{ .once = &.{
	8925	.{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
	8926	.{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	8927	} },
	8928	}, .{
	8929	.required_features = .{ .sse, null, null, null },
	8930	.src_constraints = .{
	8931	.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
	8932	.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
	8933	.any,
	8934	},
	8935	.patterns = &.{
	8936	.{ .src = .{ .to_mem, .to_mem, .none } },
	8937	},
	8938	.call_frame = .{ .alignment = .@"16" },
	8939	.extra_temps = .{
	8940	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8941	.{ .type = .f32, .kind = .{ .reg = .xmm0 } },
	8942	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncf" } } },
	8943	.unused,
	8944	.unused,
	8945	.unused,
	8946	.unused,
	8947	.unused,
	8948	.unused,
	8949	},
	8950	.dst_temps = .{ .mem, .unused },
	8951	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	8952	.each = .{ .once = &.{
	8953	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	8954	.{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
	8955	.{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
	8956	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	8957	.{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	8958	.{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
	8959	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	8960	} },
	8961	}, .{
	8962	.required_features = .{ .avx, null, null, null },
	8963	.src_constraints = .{
	8964	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	8965	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	8966	.any,
	8967	},
	8968	.patterns = &.{
	8969	.{ .src = .{ .to_sse, .mem, .none } },
	8970	.{ .src = .{ .to_sse, .to_sse, .none } },
	8971	},
	8972	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	8973	.each = .{ .once = &.{
	8974	.{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
	8975	.{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
8848	8976	} },
8849		}) catch \|err\| switch (err) {
	8977	}, .{
	8978	.required_features = .{ .avx, null, null, null },
	8979	.src_constraints = .{
	8980	.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
	8981	.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
	8982	.any,
	8983	},
	8984	.patterns = &.{
	8985	.{ .src = .{ .to_mem, .to_mem, .none } },
	8986	},
	8987	.extra_temps = .{
	8988	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	8989	.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
	8990	.unused,
	8991	.unused,
	8992	.unused,
	8993	.unused,
	8994	.unused,
	8995	.unused,
	8996	.unused,
	8997	},
	8998	.dst_temps = .{ .mem, .unused },
	8999	.clobbers = .{ .eflags = true },
	9000	.each = .{ .once = &.{
	9001	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9002	.{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
	9003	.{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
	9004	.{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	9005	.{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
	9006	.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
	9007	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9008	} },
	9009	}, .{
	9010	.required_features = .{ .sse4_1, null, null, null },
	9011	.src_constraints = .{
	9012	.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
	9013	.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
	9014	.any,
	9015	},
	9016	.patterns = &.{
	9017	.{ .src = .{ .to_mem, .to_mem, .none } },
	9018	},
	9019	.extra_temps = .{
	9020	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9021	.{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
	9022	.unused,
	9023	.unused,
	9024	.unused,
	9025	.unused,
	9026	.unused,
	9027	.unused,
	9028	.unused,
	9029	},
	9030	.dst_temps = .{ .mem, .unused },
	9031	.clobbers = .{ .eflags = true },
	9032	.each = .{ .once = &.{
	9033	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9034	.{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	9035	.{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	9036	.{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	9037	.{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	9038	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	9039	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9040	} },
	9041	}, .{
	9042	.required_features = .{ .avx, null, null, null },
	9043	.src_constraints = .{
	9044	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	9045	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	9046	.any,
	9047	},
	9048	.patterns = &.{
	9049	.{ .src = .{ .to_sse, .mem, .none } },
	9050	.{ .src = .{ .to_sse, .to_sse, .none } },
	9051	},
	9052	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	9053	.each = .{ .once = &.{
	9054	.{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
	9055	.{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }) },
	9056	} },
	9057	}, .{
	9058	.required_features = .{ .sse4_1, null, null, null },
	9059	.src_constraints = .{
	9060	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	9061	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	9062	.any,
	9063	},
	9064	.patterns = &.{
	9065	.{ .src = .{ .to_mut_sse, .mem, .none } },
	9066	.{ .src = .{ .to_mut_sse, .to_sse, .none } },
	9067	},
	9068	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	9069	.each = .{ .once = &.{
	9070	.{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
	9071	.{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	9072	} },
	9073	}, .{
	9074	.required_features = .{ .sse2, null, null, null },
	9075	.src_constraints = .{
	9076	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	9077	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	9078	.any,
	9079	},
	9080	.patterns = &.{
	9081	.{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
	9082	},
	9083	.call_frame = .{ .alignment = .@"16" },
	9084	.extra_temps = .{
	9085	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
	9086	.unused,
	9087	.unused,
	9088	.unused,
	9089	.unused,
	9090	.unused,
	9091	.unused,
	9092	.unused,
	9093	.unused,
	9094	},
	9095	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	9096	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9097	.each = .{ .once = &.{
	9098	.{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
	9099	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	9100	} },
	9101	}, .{
	9102	.required_features = .{ .sse, null, null, null },
	9103	.src_constraints = .{
	9104	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	9105	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	9106	.any,
	9107	},
	9108	.patterns = &.{
	9109	.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
	9110	},
	9111	.call_frame = .{ .alignment = .@"16" },
	9112	.extra_temps = .{
	9113	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
	9114	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
	9115	.unused,
	9116	.unused,
	9117	.unused,
	9118	.unused,
	9119	.unused,
	9120	.unused,
	9121	.unused,
	9122	},
	9123	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	9124	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9125	.each = .{ .once = &.{
	9126	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	9127	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	9128	} },
	9129	}, .{
	9130	.required_features = .{ .avx, null, null, null },
	9131	.src_constraints = .{
	9132	.{ .scalar_float = .{ .of = .xword, .is = .qword } },
	9133	.{ .scalar_float = .{ .of = .xword, .is = .qword } },
	9134	.any,
	9135	},
	9136	.patterns = &.{
	9137	.{ .src = .{ .to_sse, .mem, .none } },
	9138	.{ .src = .{ .to_sse, .to_sse, .none } },
	9139	},
	9140	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	9141	.each = .{ .once = &.{
	9142	.{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
	9143	.{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	9144	} },
	9145	}, .{
	9146	.required_features = .{ .sse4_1, null, null, null },
	9147	.src_constraints = .{
	9148	.{ .scalar_float = .{ .of = .xword, .is = .qword } },
	9149	.{ .scalar_float = .{ .of = .xword, .is = .qword } },
	9150	.any,
	9151	},
	9152	.patterns = &.{
	9153	.{ .src = .{ .to_mut_sse, .mem, .none } },
	9154	.{ .src = .{ .to_mut_sse, .to_sse, .none } },
	9155	},
	9156	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	9157	.each = .{ .once = &.{
	9158	.{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
	9159	.{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	9160	} },
	9161	}, .{
	9162	.required_features = .{ .avx, null, null, null },
	9163	.src_constraints = .{
	9164	.{ .scalar_float = .{ .of = .yword, .is = .qword } },
	9165	.{ .scalar_float = .{ .of = .yword, .is = .qword } },
	9166	.any,
	9167	},
	9168	.patterns = &.{
	9169	.{ .src = .{ .to_sse, .mem, .none } },
	9170	.{ .src = .{ .to_sse, .to_sse, .none } },
	9171	},
	9172	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	9173	.each = .{ .once = &.{
	9174	.{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
	9175	.{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	9176	} },
	9177	}, .{
	9178	.required_features = .{ .avx, null, null, null },
	9179	.src_constraints = .{
	9180	.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
	9181	.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
	9182	.any,
	9183	},
	9184	.patterns = &.{
	9185	.{ .src = .{ .to_mem, .to_mem, .none } },
	9186	},
	9187	.extra_temps = .{
	9188	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9189	.{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
	9190	.unused,
	9191	.unused,
	9192	.unused,
	9193	.unused,
	9194	.unused,
	9195	.unused,
	9196	.unused,
	9197	},
	9198	.dst_temps = .{ .mem, .unused },
	9199	.clobbers = .{ .eflags = true },
	9200	.each = .{ .once = &.{
	9201	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9202	.{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
	9203	.{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
	9204	.{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	9205	.{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
	9206	.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
	9207	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9208	} },
	9209	}, .{
	9210	.required_features = .{ .sse4_1, null, null, null },
	9211	.src_constraints = .{
	9212	.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
	9213	.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
	9214	.any,
	9215	},
	9216	.patterns = &.{
	9217	.{ .src = .{ .to_mem, .to_mem, .none } },
	9218	},
	9219	.extra_temps = .{
	9220	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9221	.{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
	9222	.unused,
	9223	.unused,
	9224	.unused,
	9225	.unused,
	9226	.unused,
	9227	.unused,
	9228	.unused,
	9229	},
	9230	.dst_temps = .{ .mem, .unused },
	9231	.clobbers = .{ .eflags = true },
	9232	.each = .{ .once = &.{
	9233	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9234	.{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	9235	.{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	9236	.{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
	9237	.{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	9238	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	9239	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9240	} },
	9241	}, .{
	9242	.required_features = .{ .sse2, null, null, null },
	9243	.src_constraints = .{
	9244	.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
	9245	.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
	9246	.any,
	9247	},
	9248	.patterns = &.{
	9249	.{ .src = .{ .to_mem, .to_mem, .none } },
	9250	},
	9251	.call_frame = .{ .alignment = .@"16" },
	9252	.extra_temps = .{
	9253	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9254	.{ .type = .f64, .kind = .{ .reg = .xmm0 } },
	9255	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
	9256	.unused,
	9257	.unused,
	9258	.unused,
	9259	.unused,
	9260	.unused,
	9261	.unused,
	9262	},
	9263	.dst_temps = .{ .mem, .unused },
	9264	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9265	.each = .{ .once = &.{
	9266	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9267	.{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
	9268	.{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
	9269	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	9270	.{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	9271	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
	9272	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9273	} },
	9274	}, .{
	9275	.required_features = .{ .sse, null, null, null },
	9276	.src_constraints = .{
	9277	.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
	9278	.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
	9279	.any,
	9280	},
	9281	.patterns = &.{
	9282	.{ .src = .{ .to_mem, .to_mem, .none } },
	9283	},
	9284	.call_frame = .{ .alignment = .@"16" },
	9285	.extra_temps = .{
	9286	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9287	.{ .type = .f64, .kind = .{ .reg = .xmm0 } },
	9288	.{ .type = .f64, .kind = .{ .reg = .xmm1 } },
	9289	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
	9290	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
	9291	.unused,
	9292	.unused,
	9293	.unused,
	9294	.unused,
	9295	},
	9296	.dst_temps = .{ .mem, .unused },
	9297	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9298	.each = .{ .once = &.{
	9299	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9300	.{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
	9301	.{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
	9302	.{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
	9303	.{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
	9304	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	9305	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	9306	.{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	9307	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
	9308	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9309	} },
	9310	}, .{
	9311	.required_features = .{ .x87, null, null, null },
	9312	.src_constraints = .{
	9313	.{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
	9314	.{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
	9315	.any,
	9316	},
	9317	.patterns = &.{
	9318	.{ .src = .{ .to_mem, .to_mem, .none } },
	9319	},
	9320	.call_frame = .{ .size = 16, .alignment = .@"16" },
	9321	.extra_temps = .{
	9322	.{ .type = .f80, .kind = .{ .reg = .st6 } },
	9323	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	9324	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	9325	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncx" } } },
	9326	.unused,
	9327	.unused,
	9328	.unused,
	9329	.unused,
	9330	.unused,
	9331	},
	9332	.dst_temps = .{ .{ .reg = .st0 }, .unused },
	9333	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9334	.each = .{ .once = &.{
	9335	.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
	9336	.{ ._, .f_, .ld, .src1t, ._, ._, ._ },
	9337	.{ ._, .f_p, .div, ._, ._, ._, ._ },
	9338	.{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
	9339	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	9340	} },
	9341	}, .{
	9342	.required_features = .{ .x87, null, null, null },
	9343	.src_constraints = .{
	9344	.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
	9345	.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
	9346	.any,
	9347	},
	9348	.patterns = &.{
	9349	.{ .src = .{ .to_mem, .to_mem, .none } },
	9350	},
	9351	.call_frame = .{ .size = 16, .alignment = .@"16" },
	9352	.extra_temps = .{
	9353	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9354	.{ .type = .f80, .kind = .{ .reg = .st6 } },
	9355	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	9356	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	9357	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncx" } } },
	9358	.unused,
	9359	.unused,
	9360	.unused,
	9361	.unused,
	9362	},
	9363	.dst_temps = .{ .mem, .unused },
	9364	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9365	.each = .{ .once = &.{
	9366	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9367	.{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
	9368	.{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
	9369	.{ ._, .f_p, .div, ._, ._, ._, ._ },
	9370	.{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
	9371	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	9372	.{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
	9373	.{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
	9374	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	9375	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9376	} },
	9377	}, .{
	9378	.required_features = .{ .sse, null, null, null },
	9379	.src_constraints = .{
	9380	.{ .scalar_float = .{ .of = .xword, .is = .xword } },
	9381	.{ .scalar_float = .{ .of = .xword, .is = .xword } },
	9382	.any,
	9383	},
	9384	.patterns = &.{
	9385	.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
	9386	},
	9387	.call_frame = .{ .alignment = .@"16" },
	9388	.extra_temps = .{
	9389	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
	9390	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
	9391	.unused,
	9392	.unused,
	9393	.unused,
	9394	.unused,
	9395	.unused,
	9396	.unused,
	9397	.unused,
	9398	},
	9399	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	9400	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9401	.each = .{ .once = &.{
	9402	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	9403	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	9404	} },
	9405	}, .{
	9406	.required_features = .{ .avx, null, null, null },
	9407	.src_constraints = .{
	9408	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	9409	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	9410	.any,
	9411	},
	9412	.patterns = &.{
	9413	.{ .src = .{ .to_mem, .to_mem, .none } },
	9414	},
	9415	.call_frame = .{ .alignment = .@"16" },
	9416	.extra_temps = .{
	9417	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9418	.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
	9419	.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
	9420	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
	9421	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
	9422	.unused,
	9423	.unused,
	9424	.unused,
	9425	.unused,
	9426	},
	9427	.dst_temps = .{ .mem, .unused },
	9428	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9429	.each = .{ .once = &.{
	9430	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9431	.{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	9432	.{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	9433	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	9434	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	9435	.{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	9436	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	9437	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9438	} },
	9439	}, .{
	9440	.required_features = .{ .sse2, null, null, null },
	9441	.src_constraints = .{
	9442	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	9443	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	9444	.any,
	9445	},
	9446	.patterns = &.{
	9447	.{ .src = .{ .to_mem, .to_mem, .none } },
	9448	},
	9449	.call_frame = .{ .alignment = .@"16" },
	9450	.extra_temps = .{
	9451	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9452	.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
	9453	.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
	9454	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
	9455	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
	9456	.unused,
	9457	.unused,
	9458	.unused,
	9459	.unused,
	9460	},
	9461	.dst_temps = .{ .mem, .unused },
	9462	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9463	.each = .{ .once = &.{
	9464	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9465	.{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	9466	.{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	9467	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	9468	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	9469	.{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	9470	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	9471	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9472	} },
	9473	}, .{
	9474	.required_features = .{ .sse, null, null, null },
	9475	.src_constraints = .{
	9476	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	9477	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	9478	.any,
	9479	},
	9480	.patterns = &.{
	9481	.{ .src = .{ .to_mem, .to_mem, .none } },
	9482	},
	9483	.call_frame = .{ .alignment = .@"16" },
	9484	.extra_temps = .{
	9485	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	9486	.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
	9487	.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
	9488	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
	9489	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
	9490	.unused,
	9491	.unused,
	9492	.unused,
	9493	.unused,
	9494	},
	9495	.dst_temps = .{ .mem, .unused },
	9496	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	9497	.each = .{ .once = &.{
	9498	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	9499	.{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	9500	.{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	9501	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	9502	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	9503	.{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	9504	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	9505	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	9506	} },
	9507	} }) catch \|err\| switch (err) {
8850	9508	error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
8851	9509	@tagName(air_tag),
8852	9510	cg.typeOf(bin_op.lhs).fmt(pt),
...	...	@@ -9982,7 +10640,1004 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
9982	10640	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9983	10641	} },
9984	10642	} },
9985		}) catch \|err\| switch (err) {
	10643	}) catch \|err\| switch (err) {
	10644	error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
	10645	@tagName(air_tag),
	10646	cg.typeOf(bin_op.lhs).fmt(pt),
	10647	ops[0].tracking(cg),
	10648	ops[1].tracking(cg),
	10649	}),
	10650	else => \|e\| return e,
	10651	};
	10652	try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
	10653	},
	10654	.div_floor => \|air_tag\| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: {
	10655	const bin_op = air_datas[@intFromEnum(inst)].bin_op;
	10656	if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag);
	10657	var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
	10658	var res: [1]Temp = undefined;
	10659	cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
	10660	.required_features = .{ .f16c, null, null, null },
	10661	.src_constraints = .{
	10662	.{ .scalar_float = .{ .of = .word, .is = .word } },
	10663	.{ .scalar_float = .{ .of = .word, .is = .word } },
	10664	.any,
	10665	},
	10666	.patterns = &.{
	10667	.{ .src = .{ .to_sse, .to_sse, .none } },
	10668	},
	10669	.extra_temps = .{
	10670	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	10671	.unused,
	10672	.unused,
	10673	.unused,
	10674	.unused,
	10675	.unused,
	10676	.unused,
	10677	.unused,
	10678	.unused,
	10679	},
	10680	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	10681	.each = .{ .once = &.{
	10682	.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
	10683	.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
	10684	.{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
	10685	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	10686	.{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
	10687	.{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
	10688	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	10689	} },
	10690	}, .{
	10691	.required_features = .{ .sse, null, null, null },
	10692	.src_constraints = .{
	10693	.{ .scalar_float = .{ .of = .word, .is = .word } },
	10694	.{ .scalar_float = .{ .of = .word, .is = .word } },
	10695	.any,
	10696	},
	10697	.patterns = &.{
	10698	.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
	10699	},
	10700	.call_frame = .{ .alignment = .@"16" },
	10701	.extra_temps = .{
	10702	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	10703	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
	10704	.unused,
	10705	.unused,
	10706	.unused,
	10707	.unused,
	10708	.unused,
	10709	.unused,
	10710	.unused,
	10711	},
	10712	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	10713	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	10714	.each = .{ .once = &.{
	10715	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	10716	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	10717	} },
	10718	}, .{
	10719	.required_features = .{ .f16c, null, null, null },
	10720	.src_constraints = .{
	10721	.{ .scalar_float = .{ .of = .qword, .is = .word } },
	10722	.{ .scalar_float = .{ .of = .qword, .is = .word } },
	10723	.any,
	10724	},
	10725	.patterns = &.{
	10726	.{ .src = .{ .mem, .mem, .none } },
	10727	.{ .src = .{ .to_sse, .mem, .none } },
	10728	.{ .src = .{ .mem, .to_sse, .none } },
	10729	.{ .src = .{ .to_sse, .to_sse, .none } },
	10730	},
	10731	.extra_temps = .{
	10732	.{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	10733	.unused,
	10734	.unused,
	10735	.unused,
	10736	.unused,
	10737	.unused,
	10738	.unused,
	10739	.unused,
	10740	.unused,
	10741	},
	10742	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	10743	.each = .{ .once = &.{
	10744	.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
	10745	.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
	10746	.{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
	10747	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	10748	.{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
	10749	.{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	10750	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	10751	} },
	10752	}, .{
	10753	.required_features = .{ .f16c, null, null, null },
	10754	.src_constraints = .{
	10755	.{ .scalar_float = .{ .of = .xword, .is = .word } },
	10756	.{ .scalar_float = .{ .of = .xword, .is = .word } },
	10757	.any,
	10758	},
	10759	.patterns = &.{
	10760	.{ .src = .{ .mem, .mem, .none } },
	10761	.{ .src = .{ .to_sse, .mem, .none } },
	10762	.{ .src = .{ .mem, .to_sse, .none } },
	10763	.{ .src = .{ .to_sse, .to_sse, .none } },
	10764	},
	10765	.extra_temps = .{
	10766	.{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	10767	.unused,
	10768	.unused,
	10769	.unused,
	10770	.unused,
	10771	.unused,
	10772	.unused,
	10773	.unused,
	10774	.unused,
	10775	},
	10776	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	10777	.each = .{ .once = &.{
	10778	.{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
	10779	.{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
	10780	.{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
	10781	.{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
	10782	.{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
	10783	.{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	10784	.{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
	10785	} },
	10786	}, .{
	10787	.required_features = .{ .f16c, null, null, null },
	10788	.src_constraints = .{
	10789	.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
	10790	.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
	10791	.any,
	10792	},
	10793	.patterns = &.{
	10794	.{ .src = .{ .to_mem, .to_mem, .none } },
	10795	},
	10796	.extra_temps = .{
	10797	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	10798	.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
	10799	.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
	10800	.unused,
	10801	.unused,
	10802	.unused,
	10803	.unused,
	10804	.unused,
	10805	.unused,
	10806	},
	10807	.dst_temps = .{ .mem, .unused },
	10808	.clobbers = .{ .eflags = true },
	10809	.each = .{ .once = &.{
	10810	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	10811	.{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	10812	.{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	10813	.{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
	10814	.{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
	10815	.{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
	10816	.{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	10817	.{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
	10818	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	10819	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	10820	} },
	10821	}, .{
	10822	.required_features = .{ .avx, null, null, null },
	10823	.src_constraints = .{
	10824	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	10825	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	10826	.any,
	10827	},
	10828	.patterns = &.{
	10829	.{ .src = .{ .to_mem, .to_mem, .none } },
	10830	},
	10831	.call_frame = .{ .alignment = .@"16" },
	10832	.extra_temps = .{
	10833	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	10834	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	10835	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	10836	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	10837	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
	10838	.unused,
	10839	.unused,
	10840	.unused,
	10841	.unused,
	10842	},
	10843	.dst_temps = .{ .mem, .unused },
	10844	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	10845	.each = .{ .once = &.{
	10846	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	10847	.{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
	10848	.{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
	10849	.{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
	10850	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	10851	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	10852	.{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
	10853	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	10854	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	10855	} },
	10856	}, .{
	10857	.required_features = .{ .sse4_1, null, null, null },
	10858	.src_constraints = .{
	10859	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	10860	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	10861	.any,
	10862	},
	10863	.patterns = &.{
	10864	.{ .src = .{ .to_mem, .to_mem, .none } },
	10865	},
	10866	.call_frame = .{ .alignment = .@"16" },
	10867	.extra_temps = .{
	10868	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	10869	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	10870	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	10871	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	10872	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
	10873	.unused,
	10874	.unused,
	10875	.unused,
	10876	.unused,
	10877	},
	10878	.dst_temps = .{ .mem, .unused },
	10879	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	10880	.each = .{ .once = &.{
	10881	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	10882	.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
	10883	.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
	10884	.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	10885	.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	10886	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	10887	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	10888	.{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
	10889	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	10890	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	10891	} },
	10892	}, .{
	10893	.required_features = .{ .sse2, null, null, null },
	10894	.src_constraints = .{
	10895	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	10896	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	10897	.any,
	10898	},
	10899	.patterns = &.{
	10900	.{ .src = .{ .to_mem, .to_mem, .none } },
	10901	},
	10902	.call_frame = .{ .alignment = .@"16" },
	10903	.extra_temps = .{
	10904	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	10905	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	10906	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	10907	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	10908	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
	10909	.{ .type = .f16, .kind = .{ .reg = .ax } },
	10910	.unused,
	10911	.unused,
	10912	.unused,
	10913	},
	10914	.dst_temps = .{ .mem, .unused },
	10915	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	10916	.each = .{ .once = &.{
	10917	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	10918	.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
	10919	.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
	10920	.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	10921	.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	10922	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	10923	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	10924	.{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
	10925	.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
	10926	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	10927	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	10928	} },
	10929	}, .{
	10930	.required_features = .{ .sse, null, null, null },
	10931	.src_constraints = .{
	10932	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	10933	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	10934	.any,
	10935	},
	10936	.patterns = &.{
	10937	.{ .src = .{ .to_mem, .to_mem, .none } },
	10938	},
	10939	.call_frame = .{ .alignment = .@"16" },
	10940	.extra_temps = .{
	10941	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	10942	.{ .type = .f16, .kind = .{ .reg = .ax } },
	10943	.{ .type = .f32, .kind = .mem },
	10944	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	10945	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	10946	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
	10947	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
	10948	.unused,
	10949	.unused,
	10950	},
	10951	.dst_temps = .{ .mem, .unused },
	10952	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	10953	.each = .{ .once = &.{
	10954	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	10955	.{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
	10956	.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
	10957	.{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
	10958	.{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
	10959	.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
	10960	.{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
	10961	.{ ._, ._, .call, .tmp5d, ._, ._, ._ },
	10962	.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
	10963	.{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
	10964	.{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
	10965	.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
	10966	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	10967	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	10968	} },
	10969	}, .{
	10970	.required_features = .{ .avx, null, null, null },
	10971	.src_constraints = .{
	10972	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	10973	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	10974	.any,
	10975	},
	10976	.patterns = &.{
	10977	.{ .src = .{ .to_sse, .mem, .none } },
	10978	.{ .src = .{ .to_sse, .to_sse, .none } },
	10979	},
	10980	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	10981	.each = .{ .once = &.{
	10982	.{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
	10983	.{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
	10984	} },
	10985	}, .{
	10986	.required_features = .{ .sse4_1, null, null, null },
	10987	.src_constraints = .{
	10988	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	10989	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	10990	.any,
	10991	},
	10992	.patterns = &.{
	10993	.{ .src = .{ .to_mut_sse, .mem, .none } },
	10994	.{ .src = .{ .to_mut_sse, .to_sse, .none } },
	10995	},
	10996	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	10997	.each = .{ .once = &.{
	10998	.{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
	10999	.{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11000	} },
	11001	}, .{
	11002	.required_features = .{ .sse, null, null, null },
	11003	.src_constraints = .{
	11004	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	11005	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	11006	.any,
	11007	},
	11008	.patterns = &.{
	11009	.{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
	11010	},
	11011	.call_frame = .{ .alignment = .@"16" },
	11012	.extra_temps = .{
	11013	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorf" } } },
	11014	.unused,
	11015	.unused,
	11016	.unused,
	11017	.unused,
	11018	.unused,
	11019	.unused,
	11020	.unused,
	11021	.unused,
	11022	},
	11023	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	11024	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11025	.each = .{ .once = &.{
	11026	.{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
	11027	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	11028	} },
	11029	}, .{
	11030	.required_features = .{ .avx, null, null, null },
	11031	.src_constraints = .{
	11032	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	11033	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	11034	.any,
	11035	},
	11036	.patterns = &.{
	11037	.{ .src = .{ .to_sse, .mem, .none } },
	11038	.{ .src = .{ .to_sse, .to_sse, .none } },
	11039	},
	11040	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	11041	.each = .{ .once = &.{
	11042	.{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
	11043	.{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11044	} },
	11045	}, .{
	11046	.required_features = .{ .sse4_1, null, null, null },
	11047	.src_constraints = .{
	11048	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	11049	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	11050	.any,
	11051	},
	11052	.patterns = &.{
	11053	.{ .src = .{ .to_mut_sse, .mem, .none } },
	11054	.{ .src = .{ .to_mut_sse, .to_sse, .none } },
	11055	},
	11056	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	11057	.each = .{ .once = &.{
	11058	.{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
	11059	.{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11060	} },
	11061	}, .{
	11062	.required_features = .{ .sse, null, null, null },
	11063	.src_constraints = .{
	11064	.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
	11065	.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
	11066	.any,
	11067	},
	11068	.patterns = &.{
	11069	.{ .src = .{ .to_mem, .to_mem, .none } },
	11070	},
	11071	.call_frame = .{ .alignment = .@"16" },
	11072	.extra_temps = .{
	11073	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11074	.{ .type = .f32, .kind = .{ .reg = .xmm0 } },
	11075	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorf" } } },
	11076	.unused,
	11077	.unused,
	11078	.unused,
	11079	.unused,
	11080	.unused,
	11081	.unused,
	11082	},
	11083	.dst_temps = .{ .mem, .unused },
	11084	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11085	.each = .{ .once = &.{
	11086	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11087	.{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
	11088	.{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
	11089	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	11090	.{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	11091	.{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
	11092	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11093	} },
	11094	}, .{
	11095	.required_features = .{ .avx, null, null, null },
	11096	.src_constraints = .{
	11097	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	11098	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	11099	.any,
	11100	},
	11101	.patterns = &.{
	11102	.{ .src = .{ .to_sse, .mem, .none } },
	11103	.{ .src = .{ .to_sse, .to_sse, .none } },
	11104	},
	11105	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	11106	.each = .{ .once = &.{
	11107	.{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
	11108	.{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11109	} },
	11110	}, .{
	11111	.required_features = .{ .avx, null, null, null },
	11112	.src_constraints = .{
	11113	.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
	11114	.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
	11115	.any,
	11116	},
	11117	.patterns = &.{
	11118	.{ .src = .{ .to_mem, .to_mem, .none } },
	11119	},
	11120	.extra_temps = .{
	11121	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11122	.{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
	11123	.unused,
	11124	.unused,
	11125	.unused,
	11126	.unused,
	11127	.unused,
	11128	.unused,
	11129	.unused,
	11130	},
	11131	.dst_temps = .{ .mem, .unused },
	11132	.clobbers = .{ .eflags = true },
	11133	.each = .{ .once = &.{
	11134	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11135	.{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
	11136	.{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
	11137	.{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11138	.{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
	11139	.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
	11140	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11141	} },
	11142	}, .{
	11143	.required_features = .{ .sse4_1, null, null, null },
	11144	.src_constraints = .{
	11145	.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
	11146	.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
	11147	.any,
	11148	},
	11149	.patterns = &.{
	11150	.{ .src = .{ .to_mem, .to_mem, .none } },
	11151	},
	11152	.extra_temps = .{
	11153	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11154	.{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
	11155	.unused,
	11156	.unused,
	11157	.unused,
	11158	.unused,
	11159	.unused,
	11160	.unused,
	11161	.unused,
	11162	},
	11163	.dst_temps = .{ .mem, .unused },
	11164	.clobbers = .{ .eflags = true },
	11165	.each = .{ .once = &.{
	11166	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11167	.{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	11168	.{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	11169	.{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11170	.{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	11171	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	11172	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11173	} },
	11174	}, .{
	11175	.required_features = .{ .avx, null, null, null },
	11176	.src_constraints = .{
	11177	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	11178	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	11179	.any,
	11180	},
	11181	.patterns = &.{
	11182	.{ .src = .{ .to_sse, .mem, .none } },
	11183	.{ .src = .{ .to_sse, .to_sse, .none } },
	11184	},
	11185	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	11186	.each = .{ .once = &.{
	11187	.{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
	11188	.{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }) },
	11189	} },
	11190	}, .{
	11191	.required_features = .{ .sse4_1, null, null, null },
	11192	.src_constraints = .{
	11193	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	11194	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	11195	.any,
	11196	},
	11197	.patterns = &.{
	11198	.{ .src = .{ .to_mut_sse, .mem, .none } },
	11199	.{ .src = .{ .to_mut_sse, .to_sse, .none } },
	11200	},
	11201	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	11202	.each = .{ .once = &.{
	11203	.{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
	11204	.{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11205	} },
	11206	}, .{
	11207	.required_features = .{ .sse2, null, null, null },
	11208	.src_constraints = .{
	11209	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	11210	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	11211	.any,
	11212	},
	11213	.patterns = &.{
	11214	.{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
	11215	},
	11216	.call_frame = .{ .alignment = .@"16" },
	11217	.extra_temps = .{
	11218	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
	11219	.unused,
	11220	.unused,
	11221	.unused,
	11222	.unused,
	11223	.unused,
	11224	.unused,
	11225	.unused,
	11226	.unused,
	11227	},
	11228	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	11229	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11230	.each = .{ .once = &.{
	11231	.{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
	11232	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	11233	} },
	11234	}, .{
	11235	.required_features = .{ .sse, null, null, null },
	11236	.src_constraints = .{
	11237	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	11238	.{ .scalar_float = .{ .of = .qword, .is = .qword } },
	11239	.any,
	11240	},
	11241	.patterns = &.{
	11242	.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
	11243	},
	11244	.call_frame = .{ .alignment = .@"16" },
	11245	.extra_temps = .{
	11246	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
	11247	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
	11248	.unused,
	11249	.unused,
	11250	.unused,
	11251	.unused,
	11252	.unused,
	11253	.unused,
	11254	.unused,
	11255	},
	11256	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	11257	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11258	.each = .{ .once = &.{
	11259	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	11260	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	11261	} },
	11262	}, .{
	11263	.required_features = .{ .avx, null, null, null },
	11264	.src_constraints = .{
	11265	.{ .scalar_float = .{ .of = .xword, .is = .qword } },
	11266	.{ .scalar_float = .{ .of = .xword, .is = .qword } },
	11267	.any,
	11268	},
	11269	.patterns = &.{
	11270	.{ .src = .{ .to_sse, .mem, .none } },
	11271	.{ .src = .{ .to_sse, .to_sse, .none } },
	11272	},
	11273	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	11274	.each = .{ .once = &.{
	11275	.{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
	11276	.{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11277	} },
	11278	}, .{
	11279	.required_features = .{ .sse4_1, null, null, null },
	11280	.src_constraints = .{
	11281	.{ .scalar_float = .{ .of = .xword, .is = .qword } },
	11282	.{ .scalar_float = .{ .of = .xword, .is = .qword } },
	11283	.any,
	11284	},
	11285	.patterns = &.{
	11286	.{ .src = .{ .to_mut_sse, .mem, .none } },
	11287	.{ .src = .{ .to_mut_sse, .to_sse, .none } },
	11288	},
	11289	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	11290	.each = .{ .once = &.{
	11291	.{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
	11292	.{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11293	} },
	11294	}, .{
	11295	.required_features = .{ .avx, null, null, null },
	11296	.src_constraints = .{
	11297	.{ .scalar_float = .{ .of = .yword, .is = .qword } },
	11298	.{ .scalar_float = .{ .of = .yword, .is = .qword } },
	11299	.any,
	11300	},
	11301	.patterns = &.{
	11302	.{ .src = .{ .to_sse, .mem, .none } },
	11303	.{ .src = .{ .to_sse, .to_sse, .none } },
	11304	},
	11305	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
	11306	.each = .{ .once = &.{
	11307	.{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
	11308	.{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11309	} },
	11310	}, .{
	11311	.required_features = .{ .avx, null, null, null },
	11312	.src_constraints = .{
	11313	.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
	11314	.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
	11315	.any,
	11316	},
	11317	.patterns = &.{
	11318	.{ .src = .{ .to_mem, .to_mem, .none } },
	11319	},
	11320	.extra_temps = .{
	11321	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11322	.{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
	11323	.unused,
	11324	.unused,
	11325	.unused,
	11326	.unused,
	11327	.unused,
	11328	.unused,
	11329	.unused,
	11330	},
	11331	.dst_temps = .{ .mem, .unused },
	11332	.clobbers = .{ .eflags = true },
	11333	.each = .{ .once = &.{
	11334	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11335	.{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
	11336	.{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
	11337	.{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11338	.{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
	11339	.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
	11340	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11341	} },
	11342	}, .{
	11343	.required_features = .{ .sse4_1, null, null, null },
	11344	.src_constraints = .{
	11345	.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
	11346	.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
	11347	.any,
	11348	},
	11349	.patterns = &.{
	11350	.{ .src = .{ .to_mem, .to_mem, .none } },
	11351	},
	11352	.extra_temps = .{
	11353	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11354	.{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
	11355	.unused,
	11356	.unused,
	11357	.unused,
	11358	.unused,
	11359	.unused,
	11360	.unused,
	11361	.unused,
	11362	},
	11363	.dst_temps = .{ .mem, .unused },
	11364	.clobbers = .{ .eflags = true },
	11365	.each = .{ .once = &.{
	11366	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11367	.{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	11368	.{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	11369	.{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
	11370	.{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	11371	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	11372	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11373	} },
	11374	}, .{
	11375	.required_features = .{ .sse2, null, null, null },
	11376	.src_constraints = .{
	11377	.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
	11378	.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
	11379	.any,
	11380	},
	11381	.patterns = &.{
	11382	.{ .src = .{ .to_mem, .to_mem, .none } },
	11383	},
	11384	.call_frame = .{ .alignment = .@"16" },
	11385	.extra_temps = .{
	11386	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11387	.{ .type = .f64, .kind = .{ .reg = .xmm0 } },
	11388	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
	11389	.unused,
	11390	.unused,
	11391	.unused,
	11392	.unused,
	11393	.unused,
	11394	.unused,
	11395	},
	11396	.dst_temps = .{ .mem, .unused },
	11397	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11398	.each = .{ .once = &.{
	11399	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11400	.{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
	11401	.{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
	11402	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	11403	.{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	11404	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
	11405	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11406	} },
	11407	}, .{
	11408	.required_features = .{ .sse, null, null, null },
	11409	.src_constraints = .{
	11410	.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
	11411	.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
	11412	.any,
	11413	},
	11414	.patterns = &.{
	11415	.{ .src = .{ .to_mem, .to_mem, .none } },
	11416	},
	11417	.call_frame = .{ .alignment = .@"16" },
	11418	.extra_temps = .{
	11419	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11420	.{ .type = .f64, .kind = .{ .reg = .xmm0 } },
	11421	.{ .type = .f64, .kind = .{ .reg = .xmm1 } },
	11422	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
	11423	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
	11424	.unused,
	11425	.unused,
	11426	.unused,
	11427	.unused,
	11428	},
	11429	.dst_temps = .{ .mem, .unused },
	11430	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11431	.each = .{ .once = &.{
	11432	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11433	.{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
	11434	.{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
	11435	.{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
	11436	.{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
	11437	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	11438	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	11439	.{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	11440	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
	11441	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11442	} },
	11443	}, .{
	11444	.required_features = .{ .x87, null, null, null },
	11445	.src_constraints = .{
	11446	.{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
	11447	.{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
	11448	.any,
	11449	},
	11450	.patterns = &.{
	11451	.{ .src = .{ .to_mem, .to_mem, .none } },
	11452	},
	11453	.call_frame = .{ .size = 16, .alignment = .@"16" },
	11454	.extra_temps = .{
	11455	.{ .type = .f80, .kind = .{ .reg = .st6 } },
	11456	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	11457	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	11458	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorx" } } },
	11459	.unused,
	11460	.unused,
	11461	.unused,
	11462	.unused,
	11463	.unused,
	11464	},
	11465	.dst_temps = .{ .{ .reg = .st0 }, .unused },
	11466	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11467	.each = .{ .once = &.{
	11468	.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
	11469	.{ ._, .f_, .ld, .src1t, ._, ._, ._ },
	11470	.{ ._, .f_p, .div, ._, ._, ._, ._ },
	11471	.{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
	11472	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	11473	} },
	11474	}, .{
	11475	.required_features = .{ .x87, null, null, null },
	11476	.src_constraints = .{
	11477	.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
	11478	.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
	11479	.any,
	11480	},
	11481	.patterns = &.{
	11482	.{ .src = .{ .to_mem, .to_mem, .none } },
	11483	},
	11484	.call_frame = .{ .size = 16, .alignment = .@"16" },
	11485	.extra_temps = .{
	11486	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11487	.{ .type = .f80, .kind = .{ .reg = .st6 } },
	11488	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	11489	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	11490	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorx" } } },
	11491	.unused,
	11492	.unused,
	11493	.unused,
	11494	.unused,
	11495	},
	11496	.dst_temps = .{ .mem, .unused },
	11497	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11498	.each = .{ .once = &.{
	11499	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11500	.{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
	11501	.{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
	11502	.{ ._, .f_p, .div, ._, ._, ._, ._ },
	11503	.{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
	11504	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	11505	.{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
	11506	.{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
	11507	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	11508	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11509	} },
	11510	}, .{
	11511	.required_features = .{ .sse, null, null, null },
	11512	.src_constraints = .{
	11513	.{ .scalar_float = .{ .of = .xword, .is = .xword } },
	11514	.{ .scalar_float = .{ .of = .xword, .is = .xword } },
	11515	.any,
	11516	},
	11517	.patterns = &.{
	11518	.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
	11519	},
	11520	.call_frame = .{ .alignment = .@"16" },
	11521	.extra_temps = .{
	11522	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
	11523	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
	11524	.unused,
	11525	.unused,
	11526	.unused,
	11527	.unused,
	11528	.unused,
	11529	.unused,
	11530	.unused,
	11531	},
	11532	.dst_temps = .{ .{ .ref = .src0 }, .unused },
	11533	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11534	.each = .{ .once = &.{
	11535	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	11536	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	11537	} },
	11538	}, .{
	11539	.required_features = .{ .avx, null, null, null },
	11540	.src_constraints = .{
	11541	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	11542	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	11543	.any,
	11544	},
	11545	.patterns = &.{
	11546	.{ .src = .{ .to_mem, .to_mem, .none } },
	11547	},
	11548	.call_frame = .{ .alignment = .@"16" },
	11549	.extra_temps = .{
	11550	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11551	.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
	11552	.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
	11553	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
	11554	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
	11555	.unused,
	11556	.unused,
	11557	.unused,
	11558	.unused,
	11559	},
	11560	.dst_temps = .{ .mem, .unused },
	11561	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11562	.each = .{ .once = &.{
	11563	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11564	.{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	11565	.{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	11566	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	11567	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	11568	.{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	11569	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	11570	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11571	} },
	11572	}, .{
	11573	.required_features = .{ .sse2, null, null, null },
	11574	.src_constraints = .{
	11575	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	11576	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	11577	.any,
	11578	},
	11579	.patterns = &.{
	11580	.{ .src = .{ .to_mem, .to_mem, .none } },
	11581	},
	11582	.call_frame = .{ .alignment = .@"16" },
	11583	.extra_temps = .{
	11584	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11585	.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
	11586	.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
	11587	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
	11588	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
	11589	.unused,
	11590	.unused,
	11591	.unused,
	11592	.unused,
	11593	},
	11594	.dst_temps = .{ .mem, .unused },
	11595	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11596	.each = .{ .once = &.{
	11597	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11598	.{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	11599	.{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	11600	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	11601	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	11602	.{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	11603	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	11604	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11605	} },
	11606	}, .{
	11607	.required_features = .{ .sse, null, null, null },
	11608	.src_constraints = .{
	11609	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	11610	.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
	11611	.any,
	11612	},
	11613	.patterns = &.{
	11614	.{ .src = .{ .to_mem, .to_mem, .none } },
	11615	},
	11616	.call_frame = .{ .alignment = .@"16" },
	11617	.extra_temps = .{
	11618	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	11619	.{ .type = .f128, .kind = .{ .reg = .xmm0 } },
	11620	.{ .type = .f128, .kind = .{ .reg = .xmm1 } },
	11621	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
	11622	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
	11623	.unused,
	11624	.unused,
	11625	.unused,
	11626	.unused,
	11627	},
	11628	.dst_temps = .{ .mem, .unused },
	11629	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	11630	.each = .{ .once = &.{
	11631	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	11632	.{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	11633	.{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	11634	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	11635	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	11636	.{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
	11637	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	11638	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	11639	} },
	11640	} }) catch \|err\| switch (err) {
9986	11641	error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
9987	11642	@tagName(air_tag),
9988	11643	cg.typeOf(bin_op.lhs).fmt(pt),
...	...	@@ -37825,7 +39480,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
37825	39480	const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
37826	39481	try cg.spillEflagsIfOccupied();
37827	39482	var ops = try cg.tempsFromOperands(inst, .{un_op});
37828		while (try ops[0].toBase(cg)) {}
	39483	while (try ops[0].toBase(false, cg)) {}
37829	39484	try cg.asmMemoryImmediate(
37830	39485	.{ ._, .cmp },
37831	39486	try ops[0].tracking(cg).short.mem(cg, .{
...	...	@@ -37850,7 +39505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
37850	39505	const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
37851	39506	try cg.spillEflagsIfOccupied();
37852	39507	var ops = try cg.tempsFromOperands(inst, .{un_op});
37853		while (try ops[0].toBase(cg)) {}
	39508	while (try ops[0].toBase(false, cg)) {}
37854	39509	try cg.asmMemoryImmediate(
37855	39510	.{ ._, .cmp },
37856	39511	try ops[0].tracking(cg).short.mem(cg, .{
...	...	@@ -37921,7 +39576,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
37921	39576	const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
37922	39577	try cg.spillEflagsIfOccupied();
37923	39578	var ops = try cg.tempsFromOperands(inst, .{un_op});
37924		while (try ops[0].toBase(cg)) {}
	39579	while (try ops[0].toBase(false, cg)) {}
37925	39580	try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
37926	39581	.size = cg.memSize(eu_err_ty),
37927	39582	.disp = eu_err_off,
...	...	@@ -37937,7 +39592,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
37937	39592	const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
37938	39593	try cg.spillEflagsIfOccupied();
37939	39594	var ops = try cg.tempsFromOperands(inst, .{un_op});
37940		while (try ops[0].toBase(cg)) {}
	39595	while (try ops[0].toBase(false, cg)) {}
37941	39596	try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
37942	39597	.size = cg.memSize(eu_err_ty),
37943	39598	.disp = eu_err_off,
...	...	@@ -88424,7 +90079,7 @@ const Temp = struct {
88424	90079	try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
88425	90080	cg.temp_type[@intFromEnum(new_temp_index)] = ty;
88426	90081	new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
88427		while (try temp.toBase(cg)) {}
	90082	while (try temp.toBase(false, cg)) {}
88428	90083	try temp.readTo(ty, .{ .register = new_reg }, .{}, cg);
88429	90084	try temp.die(cg);
88430	90085	temp.* = .{ .index = new_temp_index.toIndex() };
...	...	@@ -88447,7 +90102,7 @@ const Temp = struct {
88447	90102	for (new_regs) \|new_reg\| try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
88448	90103	cg.temp_type[@intFromEnum(new_temp_index)] = ty;
88449	90104	new_temp_index.tracking(cg).* = .init(.{ .register_pair = new_regs });
88450		while (try temp.toBase(cg)) {}
	90105	while (try temp.toBase(false, cg)) {}
88451	90106	for (new_regs, 0..) \|new_reg, reg_index\| try temp.readTo(
88452	90107	.usize,
88453	90108	.{ .register = new_reg },
...	...	@@ -88548,9 +90203,9 @@ const Temp = struct {
88548	90203	}
88549	90204	}
88550	90205
88551		fn toMemory(temp: Temp, cg: CodeGen) InnerError!bool {
	90206	fn toMemory(temp: Temp, mut: bool, cg: CodeGen) InnerError!bool {
88552	90207	const temp_tracking = temp.tracking(cg);
88553		if (temp_tracking.short.isMemory()) return false;
	90208	if ((!mut or temp.isMut(cg)) and temp_tracking.short.isMemory()) return false;
88554	90209	const new_temp_index = cg.next_temp_index;
88555	90210	const ty = temp.typeOf(cg);
88556	90211	cg.temp_type[@intFromEnum(new_temp_index)] = ty;
...	...	@@ -88564,10 +90219,10 @@ const Temp = struct {
88564	90219	}
88565	90220
88566	90221	// hack around linker relocation bugs
88567		fn toBase(temp: Temp, cg: CodeGen) InnerError!bool {
	90222	fn toBase(temp: Temp, mut: bool, cg: CodeGen) InnerError!bool {
88568	90223	const temp_tracking = temp.tracking(cg);
88569		if (temp_tracking.short.isBase()) return false;
88570		if (try temp.toMemory(cg)) return true;
	90224	if ((!mut or temp.isMut(cg)) and temp_tracking.short.isBase()) return false;
	90225	if (try temp.toMemory(mut, cg)) return true;
88571	90226	const new_temp_index = cg.next_temp_index;
88572	90227	cg.temp_type[@intFromEnum(new_temp_index)] = temp.typeOf(cg);
88573	90228	const new_reg =
...	...	@@ -88722,7 +90377,7 @@ const Temp = struct {
88722	90377
88723	90378	fn read(src: Temp, val_ty: Type, opts: AccessOptions, cg: CodeGen) InnerError!Temp {
88724	90379	var val = try cg.tempAlloc(val_ty);
88725		while (try src.toBase(cg)) {}
	90380	while (try src.toBase(false, cg)) {}
88726	90381	try src.readTo(val_ty, val.tracking(cg).short, opts, cg);
88727	90382	return val;
88728	90383	}
...	...	@@ -88763,8 +90418,8 @@ const Temp = struct {
88763	90418
88764	90419	fn write(dst: Temp, val: Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {
88765	90420	const val_ty = val.typeOf(cg);
88766		while (try dst.toBase(cg)) {}
88767		val_to_gpr: while (true) : (while (try dst.toBase(cg) or
	90421	while (try dst.toBase(false, cg)) {}
	90422	val_to_gpr: while (true) : (while (try dst.toBase(false, cg) or
88768	90423	try val.toRegClass(false, .general_purpose, cg))
88769	90424	{}) {
88770	90425	const val_mcv = val.tracking(cg).short;
...	...	@@ -90770,7 +92425,8 @@ const Select = struct {
90770	92425	fn convert(src: Src, temp: Temp, cg: CodeGen) InnerError!bool {
90771	92426	return switch (src) {
90772	92427	.none, .imm8, .imm16, .imm32, .simm32 => false,
90773		.mem, .to_mem, .mut_mem, .to_mut_mem => try temp.toBase(cg),
	92428	.mem, .to_mem => try temp.toBase(false, cg),
	92429	.mut_mem, .to_mut_mem => try temp.toBase(true, cg),
90774	92430	.to_reg => \|reg\| try temp.toReg(reg, cg),
90775	92431	.to_reg_pair => \|regs\| try temp.toRegPair(regs, cg),
90776	92432	.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 {
90814	92470	rc_mask: struct { rc: Register.Class, info: MaskInfo },
90815	92471	mut_rc_mask: struct { ref: Select.Operand.Ref, rc: Register.Class, info: MaskInfo },
90816	92472	mem,
	92473	mem_of_type: Select.Operand.Ref,
90817	92474	smin_mem: ConstSpec,
90818	92475	smax_mem: ConstSpec,
90819	92476	umin_mem: ConstSpec,
...	...	@@ -90835,9 +92492,9 @@ const Select = struct {
90835	92492
90836	92493	const CallConvRegSpec = struct {
90837	92494	cc: Case.CallConv,
90838		index: u1,
	92495	index: u2,
90839	92496
90840		fn tag(spec: CallConvRegSpec, cg: *CodeGen) std.builtin.CallingConvention.Tag {
	92497	fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag {
90841	92498	return switch (spec.cc) {
90842	92499	.none => unreachable,
90843	92500	.ccc => cg.target.cCallingConvention().?,
...	...	@@ -90846,27 +92503,39 @@ const Select = struct {
90846	92503	}
90847	92504	};
90848	92505
90849		fn finish(kind: Kind, temp: Temp, s: *const Select) void {
90850		switch (kind) {
90851		else => {},
90852		inline .rc_mask, .mut_rc_mask, .ref_mask => \|mask\| temp.asMask(mask.info, s.cg),
	92506	fn lock(kind: Kind, cg: *CodeGen) ![2]?RegisterLock {
	92507	var reg_locks: [2]?RegisterLock = @splat(null);
	92508	const regs: [2]Register = switch (kind) {
	92509	else => return reg_locks,
	92510	.reg => \|reg\| .{ reg, .none },
	92511	.reg_pair => \|regs\| regs,
	92512	.param_gpr => \|param_spec\| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..1].* ++ .{.none},
	92513	.param_gpr_pair => \|param_spec\| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*,
	92514	.ret_gpr => \|ret_spec\| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..1].* ++ .{.none},
	92515	.ret_gpr_pair => \|ret_spec\| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
	92516	};
	92517	for (regs, &reg_locks) \|reg, *reg_lock\| {
	92518	if (reg == .none) continue;
	92519	const reg_index = RegisterManager.indexOfRegIntoTracked(reg) orelse continue;
	92520	try cg.register_manager.getRegIndex(reg_index, null);
	92521	reg_lock.* = cg.register_manager.lockRegIndex(reg_index);
90853	92522	}
	92523	return reg_locks;
90854	92524	}
90855	92525
90856		fn pass(kind: Kind) u2 {
90857		return switch (kind) {
90858		.unused => 0,
90859		.reg, .reg_pair, .param_gpr, .param_gpr_pair, .ret_gpr, .ret_gpr_pair => 1,
90860		else => 2,
90861		};
	92526	fn finish(kind: Kind, temp: Temp, cg: *CodeGen) void {
	92527	switch (kind) {
	92528	else => {},
	92529	inline .rc_mask, .mut_rc_mask, .ref_mask => \|mask\| temp.asMask(mask.info, cg),
	92530	}
90862	92531	}
90863	92532	};
90864	92533
90865		fn create(spec: TempSpec, s: *Select) InnerError!struct { Temp, bool } {
	92534	fn create(spec: TempSpec, s: *const Select) InnerError!struct { Temp, bool } {
90866	92535	const cg = s.cg;
90867	92536	const pt = cg.pt;
90868	92537	return switch (spec.kind) {
90869		.unused => unreachable,
	92538	.unused => .{ undefined, false },
90870	92539	.any => .{ try cg.tempAlloc(spec.type), true },
90871	92540	.cc => \|cc\| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true },
90872	92541	.ref => \|ref\| .{ ref.tempOf(s), false },
...	...	@@ -90882,7 +92551,7 @@ const Select = struct {
90882	92551	.register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index],
90883	92552	}), true },
90884	92553	.ret_gpr_pair => \|ret_spec\| .{ try cg.tempInit(spec.type, .{
90885		.register_pair = abi.getCAbiIntParamRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
	92554	.register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
90886	92555	}), true },
90887	92556	.rc => \|rc\| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true },
90888	92557	.rc_pair => \|rc\| .{ try cg.tempAllocRegPair(spec.type, regSetForRegClass(rc)), true },
...	...	@@ -90907,6 +92576,7 @@ const Select = struct {
90907	92576	return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true };
90908	92577	},
90909	92578	.mem => .{ try cg.tempAllocMem(spec.type), true },
	92579	.mem_of_type => \|ref\| .{ try cg.tempAllocMem(ref.typeOf(s)), true },
90910	92580	.smin_mem, .smax_mem, .umin_mem, .umax_mem, .@"0x1p63_mem" => \|const_spec\| {
90911	92581	const zcu = pt.zcu;
90912	92582	const ip = &zcu.intern_pool;
...	...	@@ -91922,15 +93592,10 @@ fn select(
91922	93592
91923	93593	@memcpy(s_src_temps[0..src_temps.len], src_temps);
91924	93594	std.mem.swap(Temp, &s_src_temps[pattern.commute[0]], &s_src_temps[pattern.commute[1]]);
91925		for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) \|*dst_temp, dst_ty, dst_kind\| {
91926		if (dst_kind.pass() != 1) continue;
91927		dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s);
91928		}
91929		var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
91930		for (1..3) \|pass\| for (s_tmp_temps, &tmp_owned, case.extra_temps) \|temp, owned, spec\| {
91931		if (spec.kind.pass() != pass) continue;
91932		temp., owned. = try spec.create(&s);
91933		};
	93595	var dst_locks: [s_dst_temps.len][2]?RegisterLock = @splat(@splat(null));
	93596	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);
	93597	var tmp_locks: [s_tmp_temps.len][2]?RegisterLock = @splat(@splat(null));
	93598	for (&tmp_locks, case.extra_temps) \|tmp_lock, tmp_spec\| tmp_lock. = try tmp_spec.kind.lock(cg);
91934	93599
91935	93600	while (true) for (pattern.src[0..src_temps.len], src_temps) \|src_pattern, *src_temp\| {
91936	93601	if (try src_pattern.convert(src_temp, cg)) break;
...	...	@@ -91940,10 +93605,9 @@ fn select(
91940	93605
91941	93606	if (case.clobbers.eflags) try cg.spillEflagsIfOccupied();
91942	93607
91943		for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) \|*dst_temp, dst_ty, dst_kind\| {
91944		if (dst_kind.pass() != 2) continue;
91945		dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s);
91946		}
	93608	var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
	93609	for (s_tmp_temps, &tmp_owned, case.extra_temps) \|temp, owned, tmp_spec\| temp., owned. = try tmp_spec.create(&s);
	93610	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);
91947	93611	@memcpy(s_dst_temps[0..dst_temps.len], dst_temps);
91948	93612
91949	93613	switch (case.each) {
...	...	@@ -91954,6 +93618,8 @@ fn select(
91954	93618	}
91955	93619	assert(s.top == 0);
91956	93620
	93621	for (tmp_locks) \|locks\| for (locks) \|lock\| if (lock) \|reg\| cg.register_manager.unlockReg(reg);
	93622	for (dst_locks) \|locks\| for (locks) \|lock\| if (lock) \|reg\| cg.register_manager.unlockReg(reg);
91957	93623	caller_preserved: {
91958	93624	const cc = switch (case.clobbers.caller_preserved) {
91959	93625	.none => break :caller_preserved,
...	...	@@ -91972,7 +93638,7 @@ fn select(
91972	93638	},
91973	93639	}
91974	93640	}
91975		for (dst_temps, case.dst_temps[0..dst_temps.len]) \|dst_temp, dst_kind\| dst_kind.finish(dst_temp, &s);
	93641	for (dst_temps, case.dst_temps[0..dst_temps.len]) \|dst_temp, tmp_kind\| tmp_kind.finish(dst_temp, cg);
91976	93642	for (tmp_owned, s_tmp_temps) \|owned, temp\| if (owned) try temp.die(cg);
91977	93643	return;
91978	93644	}

test/behavior/x86_64/math.zig+41-32

...	...	@@ -17978,8 +17978,8 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela
17978	17978	-0x12, -0x1e, 0x18, 0x6e, 0x31, 0x53, -0x6a, -0x34, 0x13, 0x4d, 0x30, -0x7d, -0x31, 0x1e, -0x24, 0x32,
17979	17979	-0x1e, -0x01, 0x55, 0x33, -0x75, -0x44, -0x57, 0x2b, -0x66, 0x19, 0x7f, -0x28, -0x3f, -0x7e, -0x5d, -0x06,
17980	17980	}, .{
17981		0x05, -0x23, 0x43, -0x54, -0x41, 0x7f, -0x6a, -0x31, 0x04, 0x15, -0x7a, -0x37, 0x6d, 0x16, 0x00, 0x4a,
17982		0x15, 0x55, -0x4a, 0x16, -0x73, -0x0c, 0x1c, -0x26, -0x14, 0x00, 0x55, 0x7b, 0x16, -0x2e, -0x5f, -0x67,
	17981	0x05, -0x23, 0x43, -0x54, -0x41, 0x7f, -0x6a, -0x31, 0x04, 0x15, -0x7a, -0x37, 0x6d, 0x16, 0x01, 0x4a,
	17982	0x15, 0x55, -0x4a, 0x16, -0x73, -0x0c, 0x1c, -0x26, -0x14, -0x01, 0x55, 0x7b, 0x16, -0x2e, -0x5f, -0x67,
17983	17983	});
17984	17984	try testArgs(@Vector(64, i8), .{
17985	17985	-0x05, 0x76, 0x4e, -0x5c, 0x7b, -0x1a, -0x38, -0x2e, 0x3d, 0x36, 0x01, 0x30, -0x02, -0x71, -0x24, 0x24,
...	...	@@ -18008,7 +18008,7 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela
18008	18008	0x23, 0x3b, 0x0a, 0x7a, 0x19, 0x14, 0x65, -0x1d, 0x2b, 0x65, 0x33, 0x2a, 0x52, -0x63, 0x57, 0x10,
18009	18009	-0x1b, 0x26, -0x46, -0x7e, -0x25, 0x79, -0x01, -0x0d, -0x49, -0x4d, 0x74, 0x03, 0x77, 0x16, 0x03, -0x3d,
18010	18010	0x1c, 0x25, 0x5a, -0x2f, -0x16, -0x5f, -0x36, -0x55, -0x44, -0x0c, -0x0f, 0x7b, -0x15, -0x1d, 0x32, 0x31,
18011		0x6e, -0x44, -0x4a, -0x64, 0x67, 0x04, 0x47, 0x00, 0x3c, -0x0a, -0x79, 0x3d, 0x48, 0x5a, 0x61, -0x2c,
	18011	0x6e, -0x44, -0x4a, -0x64, 0x67, 0x04, 0x47, -0x02, 0x3c, -0x0a, -0x79, 0x3d, 0x48, 0x5a, 0x61, -0x2c,
18012	18012	0x6d, -0x68, -0x71, -0x6b, -0x11, 0x44, -0x75, -0x55, -0x67, -0x52, 0x64, -0x3d, -0x05, -0x76, -0x6d, -0x44,
18013	18013	});
18014	18014
...	...	@@ -18035,7 +18035,7 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela
18035	18035	try testArgs(@Vector(16, u8), .{
18036	18036	0xea, 0x80, 0xbb, 0xe8, 0x74, 0x81, 0xc8, 0x66, 0x7b, 0x41, 0x90, 0xcb, 0x30, 0x70, 0x4b, 0x0f,
18037	18037	}, .{
18038		0x61, 0x26, 0xbe, 0x47, 0x00, 0x9c, 0x55, 0xa5, 0x59, 0xf0, 0xb2, 0x20, 0x30, 0xaf, 0x82, 0x3e,
	18038	0x61, 0x26, 0xbe, 0x47, 0x02, 0x9c, 0x55, 0xa5, 0x59, 0xf0, 0xb2, 0x20, 0x30, 0xaf, 0x82, 0x3e,
18039	18039	});
18040	18040	try testArgs(@Vector(32, u8), .{
18041	18041	0xa1, 0x88, 0xc4, 0xf4, 0x77, 0x0b, 0xf5, 0xbb, 0x09, 0x03, 0xbf, 0xf5, 0xcc, 0x7f, 0x6b, 0x2a,
...	...	@@ -18976,12 +18976,12 @@ test addUnsafe {
18976	18976	inline fn subUnsafe(comptime Type: type, lhs: Type, rhs: Type) AddOneBit(Type) {
18977	18977	@setRuntimeSafety(false);
18978	18978	switch (@typeInfo(Scalar(Type))) {
	18979	else => @compileError(@typeName(Type)),
18979	18980	.int => \|int\| switch (int.signedness) {
18980	18981	.signed => {},
18981	18982	.unsigned => return @as(AddOneBit(Type), @max(lhs, rhs)) - @min(lhs, rhs),
18982	18983	},
18983	18984	.float => {},
18984		else => @compileError(@typeName(Type)),
18985	18985	}
18986	18986	return @as(AddOneBit(Type), lhs) - rhs;
18987	18987	}
...	...	@@ -19024,42 +19024,51 @@ test divide {
19024	19024	try test_divide.testFloatVectors();
19025	19025	}
19026	19026
19027		// workaround https://github.com/ziglang/zig/issues/22748
19028		// TODO: @TypeOf(@divTrunc(lhs, rhs))
19029		inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs / rhs) {
19030		if (@inComptime()) {
19031		// workaround https://github.com/ziglang/zig/issues/22748
19032		return @trunc(lhs / rhs);
	19027	inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) Type {
	19028	switch (@typeInfo(Scalar(Type))) {
	19029	else => @compileError(@typeName(Type)),
	19030	.int => return @divTrunc(lhs, rhs),
	19031	.float => {
	19032	if (@inComptime()) {
	19033	// workaround https://github.com/ziglang/zig/issues/22748
	19034	return @trunc(lhs / rhs);
	19035	}
	19036	// workaround https://github.com/ziglang/zig/issues/22748
	19037	// workaround https://github.com/ziglang/zig/issues/22749
	19038	// TODO: return @divTrunc(lhs, rhs);
	19039	var rt_lhs = lhs;
	19040	var rt_rhs = rhs;
	19041	_ = .{ &rt_lhs, &rt_rhs };
	19042	return @divTrunc(rt_lhs, rt_rhs);
	19043	},
19033	19044	}
19034		// workaround https://github.com/ziglang/zig/issues/22748
19035		// workaround https://github.com/ziglang/zig/issues/22749
19036		// TODO: return @divTrunc(lhs, rhs);
19037		var rt_lhs = lhs;
19038		var rt_rhs = rhs;
19039		_ = .{ &rt_lhs, &rt_rhs };
19040		return @divTrunc(rt_lhs, rt_rhs);
19041	19045	}
19042	19046	test divTrunc {
19043	19047	const test_div_trunc = binary(divTrunc, .{ .compare = .approx_int });
	19048	try test_div_trunc.testInts();
	19049	try test_div_trunc.testIntVectors();
19044	19050	try test_div_trunc.testFloats();
19045	19051	try test_div_trunc.testFloatVectors();
19046	19052	}
19047	19053
19048		// workaround https://github.com/ziglang/zig/issues/22748
19049		// TODO: @TypeOf(@divFloor(lhs, rhs))
19050		inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs / rhs) {
19051		if (@inComptime()) {
19052		// workaround https://github.com/ziglang/zig/issues/22748
19053		return @floor(lhs / rhs);
	19054	inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) Type {
	19055	switch (@typeInfo(Scalar(Type))) {
	19056	else => @compileError(@typeName(Type)),
	19057	.int => return @divFloor(lhs, rhs),
	19058	.float => {
	19059	if (@inComptime()) {
	19060	// workaround https://github.com/ziglang/zig/issues/22748
	19061	return @floor(lhs / rhs);
	19062	}
	19063	// workaround https://github.com/ziglang/zig/issues/22748
	19064	// workaround https://github.com/ziglang/zig/issues/22749
	19065	// TODO: return @divFloor(lhs, rhs);
	19066	var rt_lhs = lhs;
	19067	var rt_rhs = rhs;
	19068	_ = .{ &rt_lhs, &rt_rhs };
	19069	return @divFloor(rt_lhs, rt_rhs);
	19070	},
19054	19071	}
19055		// workaround https://github.com/ziglang/zig/issues/22748
19056		// workaround https://github.com/ziglang/zig/issues/22749
19057		// TODO: return @divFloor(lhs, rhs);
19058		var rt_lhs = lhs;
19059		var rt_rhs = rhs;
19060		_ = &rt_lhs;
19061		_ = &rt_rhs;
19062		return @divFloor(rt_lhs, rt_rhs);
19063	19072	}
19064	19073	test divFloor {
19065	19074	const test_div_floor = binary(divFloor, .{ .compare = .approx_int });

test/cases/safety/integer division by zero - vectors.zig +1-1

...	...	@@ -18,5 +18,5 @@ fn div0(a: @Vector(4, i32), b: @Vector(4, i32)) @Vector(4, i32) {
18	18	return @divTrunc(a, b);
19	19	}
20	20	// run
21		// backend=llvm
	21	// backend=stage2,llvm
22	22	// target=native

test/cases/safety/signed integer division overflow - vectors.zig +1-1

...	...	@@ -19,5 +19,5 @@ fn div(a: @Vector(4, i16), b: @Vector(4, i16)) @Vector(4, i16) {
19	19	return @divTrunc(a, b);
20	20	}
21	21	// run
22		// backend=llvm
	22	// backend=stage2,llvm
23	23	// target=native