Commit 4e4775d6bd612694540e738e9347a872bcde5036 | zig

author	Jacob Young <jacobly@ziglang.org> 2025-02-08 05:56:15-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-02-09 00:42:55-08:00
log	4e4775d6bd612694540e738e9347a872bcde5036
tree	8c6c4396436c3cc9cd2fb0a477add3976368c489
parent	138d30bb4763a5831ace21d916bde669b4ff5efb

x86_64: implement conversions between scalar floats and ints

Closes #22797

39 files changed, 7281 insertions(+), 447 deletions(-)

lib/compiler_rt.zig+25-5

...	...	@@ -61,33 +61,43 @@ comptime {
61	61	_ = @import("compiler_rt/fixhfsi.zig");
62	62	_ = @import("compiler_rt/fixhfdi.zig");
63	63	_ = @import("compiler_rt/fixhfti.zig");
	64	_ = @import("compiler_rt/fixhfei.zig");
64	65	_ = @import("compiler_rt/fixsfsi.zig");
65	66	_ = @import("compiler_rt/fixsfdi.zig");
66	67	_ = @import("compiler_rt/fixsfti.zig");
	68	_ = @import("compiler_rt/fixsfei.zig");
67	69	_ = @import("compiler_rt/fixdfsi.zig");
68	70	_ = @import("compiler_rt/fixdfdi.zig");
69	71	_ = @import("compiler_rt/fixdfti.zig");
	72	_ = @import("compiler_rt/fixdfei.zig");
70	73	_ = @import("compiler_rt/fixtfsi.zig");
71	74	_ = @import("compiler_rt/fixtfdi.zig");
72	75	_ = @import("compiler_rt/fixtfti.zig");
	76	_ = @import("compiler_rt/fixtfei.zig");
73	77	_ = @import("compiler_rt/fixxfsi.zig");
74	78	_ = @import("compiler_rt/fixxfdi.zig");
75	79	_ = @import("compiler_rt/fixxfti.zig");
	80	_ = @import("compiler_rt/fixxfei.zig");
76	81	_ = @import("compiler_rt/fixunshfsi.zig");
77	82	_ = @import("compiler_rt/fixunshfdi.zig");
78	83	_ = @import("compiler_rt/fixunshfti.zig");
	84	_ = @import("compiler_rt/fixunshfei.zig");
79	85	_ = @import("compiler_rt/fixunssfsi.zig");
80	86	_ = @import("compiler_rt/fixunssfdi.zig");
81	87	_ = @import("compiler_rt/fixunssfti.zig");
	88	_ = @import("compiler_rt/fixunssfei.zig");
82	89	_ = @import("compiler_rt/fixunsdfsi.zig");
83	90	_ = @import("compiler_rt/fixunsdfdi.zig");
84	91	_ = @import("compiler_rt/fixunsdfti.zig");
	92	_ = @import("compiler_rt/fixunsdfei.zig");
85	93	_ = @import("compiler_rt/fixunstfsi.zig");
86	94	_ = @import("compiler_rt/fixunstfdi.zig");
87	95	_ = @import("compiler_rt/fixunstfti.zig");
	96	_ = @import("compiler_rt/fixunstfei.zig");
88	97	_ = @import("compiler_rt/fixunsxfsi.zig");
89	98	_ = @import("compiler_rt/fixunsxfdi.zig");
90	99	_ = @import("compiler_rt/fixunsxfti.zig");
	100	_ = @import("compiler_rt/fixunsxfei.zig");
91	101
92	102	_ = @import("compiler_rt/float_from_int.zig");
93	103	_ = @import("compiler_rt/floatsihf.zig");
...	...	@@ -105,21 +115,31 @@ comptime {
105	115	_ = @import("compiler_rt/floattidf.zig");
106	116	_ = @import("compiler_rt/floattitf.zig");
107	117	_ = @import("compiler_rt/floattixf.zig");
108		_ = @import("compiler_rt/floatundihf.zig");
109		_ = @import("compiler_rt/floatundisf.zig");
110		_ = @import("compiler_rt/floatundidf.zig");
111		_ = @import("compiler_rt/floatunditf.zig");
112		_ = @import("compiler_rt/floatundixf.zig");
	118	_ = @import("compiler_rt/floateihf.zig");
	119	_ = @import("compiler_rt/floateisf.zig");
	120	_ = @import("compiler_rt/floateidf.zig");
	121	_ = @import("compiler_rt/floateitf.zig");
	122	_ = @import("compiler_rt/floateixf.zig");
113	123	_ = @import("compiler_rt/floatunsihf.zig");
114	124	_ = @import("compiler_rt/floatunsisf.zig");
115	125	_ = @import("compiler_rt/floatunsidf.zig");
116	126	_ = @import("compiler_rt/floatunsitf.zig");
117	127	_ = @import("compiler_rt/floatunsixf.zig");
	128	_ = @import("compiler_rt/floatundihf.zig");
	129	_ = @import("compiler_rt/floatundisf.zig");
	130	_ = @import("compiler_rt/floatundidf.zig");
	131	_ = @import("compiler_rt/floatunditf.zig");
	132	_ = @import("compiler_rt/floatundixf.zig");
118	133	_ = @import("compiler_rt/floatuntihf.zig");
119	134	_ = @import("compiler_rt/floatuntisf.zig");
120	135	_ = @import("compiler_rt/floatuntidf.zig");
121	136	_ = @import("compiler_rt/floatuntitf.zig");
122	137	_ = @import("compiler_rt/floatuntixf.zig");
	138	_ = @import("compiler_rt/floatuneihf.zig");
	139	_ = @import("compiler_rt/floatuneisf.zig");
	140	_ = @import("compiler_rt/floatuneidf.zig");
	141	_ = @import("compiler_rt/floatuneitf.zig");
	142	_ = @import("compiler_rt/floatuneixf.zig");
123	143
124	144	// comparison
125	145	_ = @import("compiler_rt/comparef.zig");

lib/compiler_rt/divc3_test.zig+1-1

...	...	@@ -9,7 +9,7 @@ const __divdc3 = @import("./divdc3.zig").__divdc3;
9	9	const __divxc3 = @import("./divxc3.zig").__divxc3;
10	10	const __divtc3 = @import("./divtc3.zig").__divtc3;
11	11
12		test {
	12	test "divc3" {
13	13	try testDiv(f16, __divhc3);
14	14	try testDiv(f32, __divsc3);
15	15	try testDiv(f64, __divdc3);

lib/compiler_rt/fixdfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixdfei, .{ .name = "__fixdfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixdfei(r: [*]u32, bits: usize, a: f64) callconv(.c) void {
	12	return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixdfti.zig+4-1

...	...	@@ -8,7 +8,10 @@ comptime {
8	8	if (common.want_windows_v2u64_abi) {
9	9	@export(&__fixdfti_windows_x86_64, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
10	10	} else {
11		@export(&__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
	11	@export(&__fixdfti, .{ .name = switch (builtin.cpu.arch) {
	12	.hexagon => "__hexagon",
	13	else => "_",
	14	} ++ "_fixdfti", .linkage = common.linkage, .visibility = common.visibility });
12	15	}
13	16	}
14	17

lib/compiler_rt/fixhfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixhfei, .{ .name = "__fixhfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixhfei(r: [*]u32, bits: usize, a: f16) callconv(.c) void {
	12	return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixsfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixsfei, .{ .name = "__fixsfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixsfei(r: [*]u32, bits: usize, a: f32) callconv(.c) void {
	12	return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixsfti.zig+4-1

...	...	@@ -8,7 +8,10 @@ comptime {
8	8	if (common.want_windows_v2u64_abi) {
9	9	@export(&__fixsfti_windows_x86_64, .{ .name = "__fixsfti", .linkage = common.linkage, .visibility = common.visibility });
10	10	} else {
11		@export(&__fixsfti, .{ .name = "__fixsfti", .linkage = common.linkage, .visibility = common.visibility });
	11	@export(&__fixsfti, .{ .name = switch (builtin.cpu.arch) {
	12	.hexagon => "__hexagon",
	13	else => "_",
	14	} ++ "_fixsfti", .linkage = common.linkage, .visibility = common.visibility });
12	15	}
13	16	}
14	17

lib/compiler_rt/fixtfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixtfei, .{ .name = "__fixtfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixtfei(r: [*]u32, bits: usize, a: f128) callconv(.c) void {
	12	return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixunsdfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixunsdfei, .{ .name = "__fixunsdfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixunsdfei(r: [*]u32, bits: usize, a: f64) callconv(.c) void {
	12	return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixunsdfti.zig+4-1

...	...	@@ -8,7 +8,10 @@ comptime {
8	8	if (common.want_windows_v2u64_abi) {
9	9	@export(&__fixunsdfti_windows_x86_64, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
10	10	} else {
11		@export(&__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
	11	@export(&__fixunsdfti, .{ .name = switch (builtin.cpu.arch) {
	12	.hexagon => "__hexagon",
	13	else => "_",
	14	} ++ "_fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
12	15	}
13	16	}
14	17

lib/compiler_rt/fixunshfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixunshfei, .{ .name = "__fixunshfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixunshfei(r: [*]u32, bits: usize, a: f16) callconv(.c) void {
	12	return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixunssfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixunssfei, .{ .name = "__fixunssfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixunssfei(r: [*]u32, bits: usize, a: f32) callconv(.c) void {
	12	return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixunssfti.zig+4-1

...	...	@@ -8,7 +8,10 @@ comptime {
8	8	if (common.want_windows_v2u64_abi) {
9	9	@export(&__fixunssfti_windows_x86_64, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
10	10	} else {
11		@export(&__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
	11	@export(&__fixunssfti, .{ .name = switch (builtin.cpu.arch) {
	12	.hexagon => "__hexagon",
	13	else => "_",
	14	} ++ "_fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
12	15	}
13	16	}
14	17

lib/compiler_rt/fixunstfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixunstfei, .{ .name = "__fixunstfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixunstfei(r: [*]u32, bits: usize, a: f128) callconv(.c) void {
	12	return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixunsxfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixunsxfei, .{ .name = "__fixunsxfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixunsxfei(r: [*]u32, bits: usize, a: f80) callconv(.c) void {
	12	return bigIntFromFloat(.unsigned, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/fixxfei.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const bigIntFromFloat = @import("./int_from_float.zig").bigIntFromFloat;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__fixxfei, .{ .name = "__fixxfei", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __fixxfei(r: [*]u32, bits: usize, a: f80) callconv(.c) void {
	12	return bigIntFromFloat(.signed, r[0 .. divCeil(usize, bits, 32) catch unreachable], a);
	13	}

lib/compiler_rt/float_from_int.zig+52-3

...	...	@@ -1,5 +1,6 @@
1		const Int = @import("std").meta.Int;
2		const math = @import("std").math;
	1	const std = @import("std");
	2	const Int = std.meta.Int;
	3	const math = std.math;
3	4
4	5	pub fn floatFromInt(comptime T: type, x: anytype) T {
5	6	if (x == 0) return 0;
...	...	@@ -18,7 +19,7 @@ pub fn floatFromInt(comptime T: type, x: anytype) T {
18	19	const max_exp = exp_bias;
19	20
20	21	// Sign
21		const abs_val = if (@TypeOf(x) == comptime_int or @typeInfo(@TypeOf(x)).int.signedness == .signed) @abs(x) else x;
	22	const abs_val = @abs(x);
22	23	const sign_bit = if (x < 0) @as(uT, 1) << (float_bits - 1) else 0;
23	24	var result: uT = sign_bit;
24	25
...	...	@@ -53,6 +54,54 @@ pub fn floatFromInt(comptime T: type, x: anytype) T {
53	54	return @bitCast(sign_bit \| result);
54	55	}
55	56
	57	const endian = @import("builtin").cpu.arch.endian();
	58	inline fn limb(limbs: []const u32, index: usize) u32 {
	59	return switch (endian) {
	60	.little => limbs[index],
	61	.big => limbs[limbs.len - 1 - index],
	62	};
	63	}
	64
	65	pub inline fn floatFromBigInt(comptime T: type, comptime signedness: std.builtin.Signedness, x: []const u32) T {
	66	switch (x.len) {
	67	0 => return 0,
	68	inline 1...4 => \|limbs_len\| return @floatFromInt(@as(
	69	@Type(.{ .int = .{ .signedness = signedness, .bits = 32 * limbs_len } }),
	70	@bitCast(x[0..limbs_len].*),
	71	)),
	72	else => {},
	73	}
	74
	75	// sign implicit fraction round sticky
	76	const I = comptime @Type(.{ .int = .{
	77	.signedness = signedness,
	78	.bits = @as(u16, @intFromBool(signedness == .signed)) + 1 + math.floatFractionalBits(T) + 1 + 1,
	79	} });
	80
	81	const clrsb = clrsb: {
	82	var clsb: usize = 0;
	83	const sign_bits: u32 = switch (signedness) {
	84	.signed => @bitCast(@as(i32, @bitCast(limb(x, x.len - 1))) >> 31),
	85	.unsigned => 0,
	86	};
	87	for (0..x.len) \|limb_index\| {
	88	const l = limb(x, x.len - 1 - limb_index) ^ sign_bits;
	89	clsb += @clz(l);
	90	if (l != 0) break;
	91	}
	92	break :clrsb clsb - @intFromBool(signedness == .signed);
	93	};
	94	const active_bits = 32 * x.len - clrsb;
	95	const exponent = active_bits -\| @bitSizeOf(I);
	96	const exponent_limb = exponent / 32;
	97	const sticky = for (0..exponent_limb) \|limb_index\| {
	98	if (limb(x, limb_index) != 0) break true;
	99	} else limb(x, exponent_limb) & ((@as(u32, 1) << @truncate(exponent)) - 1) != 0;
	100	return math.ldexp(@as(T, @floatFromInt(
	101	std.mem.readPackedIntNative(I, std.mem.sliceAsBytes(x), exponent) \| @intFromBool(sticky),
	102	)), @intCast(exponent));
	103	}
	104
56	105	test {
57	106	_ = @import("float_from_int_test.zig");
58	107	}

lib/compiler_rt/float_from_int_test.zig+52-2

...	...	@@ -1,6 +1,8 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const testing = std.testing;
3	4	const math = std.math;
	5	const endian = builtin.cpu.arch.endian();
4	6
5	7	const __floatunsihf = @import("floatunsihf.zig").__floatunsihf;
6	8
...	...	@@ -11,6 +13,8 @@ const __floatdisf = @import("floatdisf.zig").__floatdisf;
11	13	const __floatundisf = @import("floatundisf.zig").__floatundisf;
12	14	const __floattisf = @import("floattisf.zig").__floattisf;
13	15	const __floatuntisf = @import("floatuntisf.zig").__floatuntisf;
	16	const __floateisf = @import("floateisf.zig").__floateisf;
	17	const __floatuneisf = @import("floatuneisf.zig").__floatuneisf;
14	18
15	19	// Conversion to f64
16	20	const __floatsidf = @import("floatsidf.zig").__floatsidf;
...	...	@@ -231,6 +235,54 @@ test "floatuntisf" {
231	235	try test__floatuntisf(math.maxInt(u128), @bitCast(math.inf(f32)));
232	236	}
233	237
	238	fn test_floateisf(expected: u32, comptime T: type, a: T) !void {
	239	const int = @typeInfo(T).int;
	240	var a_buf: [@divExact(int.bits, 32)]u32 = undefined;
	241	std.mem.writeInt(T, std.mem.asBytes(&a_buf), a, endian);
	242	const r = switch (int.signedness) {
	243	.signed => __floateisf,
	244	.unsigned => __floatuneisf,
	245	}(&a_buf, int.bits);
	246	try testing.expect(expected == @as(u32, @bitCast(r)));
	247	}
	248
	249	test "floateisf" {
	250	try test_floateisf(0xFF000000, i256, -1 << 127);
	251	try test_floateisf(0xFF000000, i256, -math.maxInt(u127));
	252	try test_floateisf(0xDF012347, i256, -0x8123468100000000);
	253	try test_floateisf(0xDF012347, i256, -0x8123468000000001);
	254	try test_floateisf(0xDF012346, i256, -0x8123468000000000);
	255	try test_floateisf(0xDF012346, i256, -0x8123458100000000);
	256	try test_floateisf(0xDF012346, i256, -0x8123458000000001);
	257	try test_floateisf(0xDF012346, i256, -0x8123458000000000);
	258	try test_floateisf(0xDF012345, i256, -0x8123456789ABCDEF);
	259	try test_floateisf(0xBF800000, i256, -1);
	260	try test_floateisf(0x00000000, i256, 0);
	261	try test_floateisf(0x5F012345, i256, 0x8123456789ABCDEF);
	262	try test_floateisf(0x5F012346, i256, 0x8123458000000000);
	263	try test_floateisf(0x5F012346, i256, 0x8123458000000001);
	264	try test_floateisf(0x5F012346, i256, 0x8123458100000000);
	265	try test_floateisf(0x5F012346, i256, 0x8123468000000000);
	266	try test_floateisf(0x5F012347, i256, 0x8123468000000001);
	267	try test_floateisf(0x5F012347, i256, 0x8123468100000000);
	268	try test_floateisf(0x7F000000, i256, math.maxInt(u127));
	269	try test_floateisf(0x7F000000, i256, 1 << 127);
	270	}
	271
	272	test "floatuneisf" {
	273	try test_floateisf(0x00000000, u256, 0);
	274	try test_floateisf(0x5F012345, u256, 0x8123456789ABCDEF);
	275	try test_floateisf(0x5F012346, u256, 0x8123458000000000);
	276	try test_floateisf(0x5F012346, u256, 0x8123458000000001);
	277	try test_floateisf(0x5F012346, u256, 0x8123458080000000);
	278	try test_floateisf(0x5F012346, u256, 0x8123468000000000);
	279	try test_floateisf(0x5F012347, u256, 0x8123468000000001);
	280	try test_floateisf(0x5F012347, u256, 0x8123468080000000);
	281	try test_floateisf(0x7F000000, u256, math.maxInt(u127));
	282	try test_floateisf(0x7F000000, u256, 1 << 127);
	283	try test_floateisf(0x7F800000, u256, math.maxInt(u256));
	284	}
	285
234	286	fn test_one_floatsidf(a: i32, expected: u64) !void {
235	287	const r = __floatsidf(a);
236	288	try std.testing.expect(@as(u64, @bitCast(r)) == expected);
...	...	@@ -810,8 +862,6 @@ test "conversion to f32" {
810	862	}
811	863
812	864	test "conversion to f80" {
813		if (std.debug.runtime_safety) return error.SkipZigTest;
814
815	865	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
816	866
817	867	try testing.expect(floatFromInt(f80, @as(i80, -12)) == -12);

lib/compiler_rt/floateidf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floateidf, .{ .name = "__floateidf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floateidf(a: [*]const u32, bits: usize) callconv(.c) f64 {
	12	return floatFromBigInt(f64, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floateihf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floateihf, .{ .name = "__floateihf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floateihf(a: [*]const u32, bits: usize) callconv(.c) f16 {
	12	return floatFromBigInt(f16, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floateisf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floateisf, .{ .name = "__floateisf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floateisf(a: [*]const u32, bits: usize) callconv(.c) f32 {
	12	return floatFromBigInt(f32, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floateitf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floateitf, .{ .name = "__floateitf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floateitf(a: [*]const u32, bits: usize) callconv(.c) f128 {
	12	return floatFromBigInt(f128, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floateixf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floateixf, .{ .name = "__floateixf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floateixf(a: [*]const u32, bits: usize) callconv(.c) f80 {
	12	return floatFromBigInt(f80, .signed, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floattidf.zig+4-1

...	...	@@ -8,7 +8,10 @@ comptime {
8	8	if (common.want_windows_v2u64_abi) {
9	9	@export(&__floattidf_windows_x86_64, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
10	10	} else {
11		@export(&__floattidf, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
	11	@export(&__floattidf, .{ .name = switch (builtin.cpu.arch) {
	12	.hexagon => "__hexagon",
	13	else => "_",
	14	} ++ "_floattidf", .linkage = common.linkage, .visibility = common.visibility });
12	15	}
13	16	}
14	17

lib/compiler_rt/floattisf.zig+4-1

...	...	@@ -8,7 +8,10 @@ comptime {
8	8	if (common.want_windows_v2u64_abi) {
9	9	@export(&__floattisf_windows_x86_64, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
10	10	} else {
11		@export(&__floattisf, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
	11	@export(&__floattisf, .{ .name = switch (builtin.cpu.arch) {
	12	.hexagon => "__hexagon",
	13	else => "_",
	14	} ++ "_floattisf", .linkage = common.linkage, .visibility = common.visibility });
12	15	}
13	16	}
14	17

lib/compiler_rt/floatuneidf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floatuneidf, .{ .name = "__floatuneidf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floatuneidf(a: [*]const u32, bits: usize) callconv(.c) f64 {
	12	return floatFromBigInt(f64, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floatuneihf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floatuneihf, .{ .name = "__floatuneihf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floatuneihf(a: [*]const u32, bits: usize) callconv(.c) f16 {
	12	return floatFromBigInt(f16, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floatuneisf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floatuneisf, .{ .name = "__floatuneisf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floatuneisf(a: [*]const u32, bits: usize) callconv(.c) f32 {
	12	return floatFromBigInt(f32, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floatuneitf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floatuneitf, .{ .name = "__floatuneitf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floatuneitf(a: [*]const u32, bits: usize) callconv(.c) f128 {
	12	return floatFromBigInt(f128, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/floatuneixf.zig created+13

...	...	@@ -0,0 +1,13 @@
	1	const divCeil = @import("std").math.divCeil;
	2	const common = @import("./common.zig");
	3	const floatFromBigInt = @import("./float_from_int.zig").floatFromBigInt;
	4
	5	pub const panic = common.panic;
	6
	7	comptime {
	8	@export(&__floatuneixf, .{ .name = "__floatuneixf", .linkage = common.linkage, .visibility = common.visibility });
	9	}
	10
	11	pub fn __floatuneixf(a: [*]const u32, bits: usize) callconv(.c) f80 {
	12	return floatFromBigInt(f80, .unsigned, a[0 .. divCeil(usize, bits, 32) catch unreachable]);
	13	}

lib/compiler_rt/int_from_float.zig+52-2

...	...	@@ -1,5 +1,6 @@
1		const Int = @import("std").meta.Int;
2		const math = @import("std").math;
	1	const std = @import("std");
	2	const Int = std.meta.Int;
	3	const math = std.math;
3	4	const Log2Int = math.Log2Int;
4	5
5	6	pub inline fn intFromFloat(comptime I: type, a: anytype) I {
...	...	@@ -50,6 +51,55 @@ pub inline fn intFromFloat(comptime I: type, a: anytype) I {
50	51	return result;
51	52	}
52	53
	54	pub inline fn bigIntFromFloat(comptime signedness: std.builtin.Signedness, result: []u32, a: anytype) void {
	55	switch (result.len) {
	56	0 => return,
	57	inline 1...4 => \|limbs_len\| {
	58	result[0..limbs_len].* = @bitCast(@as(
	59	@Type(.{ .int = .{ .signedness = signedness, .bits = 32 * limbs_len } }),
	60	@intFromFloat(a),
	61	));
	62	return;
	63	},
	64	else => {},
	65	}
	66
	67	// sign implicit fraction
	68	const significand_bits = 1 + math.floatFractionalBits(@TypeOf(a));
	69	const I = @Type(comptime .{ .int = .{
	70	.signedness = signedness,
	71	.bits = @as(u16, @intFromBool(signedness == .signed)) + significand_bits,
	72	} });
	73
	74	const parts = math.frexp(a);
	75	const exponent = @max(parts.exponent - significand_bits, 0);
	76	const int: I = @intFromFloat(switch (exponent) {
	77	0 => a,
	78	else => math.ldexp(parts.significand, significand_bits),
	79	});
	80	switch (signedness) {
	81	.signed => {
	82	const endian = @import("builtin").cpu.arch.endian();
	83	const exponent_limb = switch (endian) {
	84	.little => exponent / 32,
	85	.big => result.len - 1 - exponent / 32,
	86	};
	87	const sign_bits: u32 = if (int < 0) math.maxInt(u32) else 0;
	88	@memset(result[0..exponent_limb], switch (endian) {
	89	.little => 0,
	90	.big => sign_bits,
	91	});
	92	result[exponent_limb] = sign_bits << @truncate(exponent);
	93	@memset(result[exponent_limb + 1 ..], switch (endian) {
	94	.little => sign_bits,
	95	.big => 0,
	96	});
	97	},
	98	.unsigned => @memset(result, 0),
	99	}
	100	std.mem.writePackedIntNative(I, std.mem.sliceAsBytes(result), exponent, int);
	101	}
	102
53	103	test {
54	104	_ = @import("int_from_float_test.zig");
55	105	}

lib/compiler_rt/int_from_float_test.zig+38

...	...	@@ -2,6 +2,7 @@ const std = @import("std");
2	2	const builtin = @import("builtin");
3	3	const testing = std.testing;
4	4	const math = std.math;
	5	const endian = builtin.cpu.arch.endian();
5	6
6	7	const __fixunshfti = @import("fixunshfti.zig").__fixunshfti;
7	8	const __fixunsxfti = @import("fixunsxfti.zig").__fixunsxfti;
...	...	@@ -13,6 +14,8 @@ const __fixsfdi = @import("fixsfdi.zig").__fixsfdi;
13	14	const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi;
14	15	const __fixsfti = @import("fixsfti.zig").__fixsfti;
15	16	const __fixunssfti = @import("fixunssfti.zig").__fixunssfti;
	17	const __fixsfei = @import("fixsfei.zig").__fixsfei;
	18	const __fixunssfei = @import("fixunssfei.zig").__fixunssfei;
16	19
17	20	// Conversion from f64
18	21	const __fixdfsi = @import("fixdfsi.zig").__fixdfsi;
...	...	@@ -343,6 +346,41 @@ test "fixunssfti" {
343	346	try test__fixunssfti(math.inf(f32), math.maxInt(u128));
344	347	}
345	348
	349	fn test_fixsfei(comptime T: type, expected: T, a: f32) !void {
	350	const int = @typeInfo(T).int;
	351	var expected_buf: [@divExact(int.bits, 32)]u32 = undefined;
	352	std.mem.writeInt(T, std.mem.asBytes(&expected_buf), expected, endian);
	353	var actual_buf: [@divExact(int.bits, 32)]u32 = undefined;
	354	_ = switch (int.signedness) {
	355	.signed => __fixsfei,
	356	.unsigned => __fixunssfei,
	357	}(&actual_buf, int.bits, a);
	358	try testing.expect(std.mem.eql(u32, &expected_buf, &actual_buf));
	359	}
	360
	361	test "fixsfei" {
	362	try test_fixsfei(i256, -1 << 127, -0x1p127);
	363	try test_fixsfei(i256, -1 << 100, -0x1p100);
	364	try test_fixsfei(i256, -1 << 50, -0x1p50);
	365	try test_fixsfei(i256, -1 << 1, -0x1p1);
	366	try test_fixsfei(i256, -1 << 0, -0x1p0);
	367	try test_fixsfei(i256, 0, 0);
	368	try test_fixsfei(i256, 1 << 0, 0x1p0);
	369	try test_fixsfei(i256, 1 << 1, 0x1p1);
	370	try test_fixsfei(i256, 1 << 50, 0x1p50);
	371	try test_fixsfei(i256, 1 << 100, 0x1p100);
	372	try test_fixsfei(i256, 1 << 127, 0x1p127);
	373	}
	374
	375	test "fixunsfei" {
	376	try test_fixsfei(u256, 0, 0);
	377	try test_fixsfei(u256, 1 << 0, 0x1p0);
	378	try test_fixsfei(u256, 1 << 1, 0x1p1);
	379	try test_fixsfei(u256, 1 << 50, 0x1p50);
	380	try test_fixsfei(u256, 1 << 100, 0x1p100);
	381	try test_fixsfei(u256, 1 << 127, 0x1p127);
	382	}
	383
346	384	fn test__fixdfsi(a: f64, expected: i32) !void {
347	385	const x = __fixdfsi(a);
348	386	try testing.expect(x == expected);

lib/compiler_rt/memcpy.zig+1-1

...	...	@@ -181,7 +181,7 @@ inline fn copyRange4(
181	181	dest[last..][0..copy_len].* = src[last..][0..copy_len].*;
182	182	}
183	183
184		test {
	184	test "memcpy" {
185	185	const S = struct {
186	186	fn testFunc(comptime copy_func: anytype) !void {
187	187	const max_len = 1024;

lib/compiler_rt/mulc3_test.zig+1-1

...	...	@@ -9,7 +9,7 @@ const __muldc3 = @import("./muldc3.zig").__muldc3;
9	9	const __mulxc3 = @import("./mulxc3.zig").__mulxc3;
10	10	const __multc3 = @import("./multc3.zig").__multc3;
11	11
12		test {
	12	test "mulc3" {
13	13	try testMul(f16, __mulhc3);
14	14	try testMul(f32, __mulsc3);
15	15	try testMul(f64, __muldc3);

lib/compiler_rt/trig.zig+1-1

...	...	@@ -222,7 +222,7 @@ pub fn __tan(x_: f64, y_: f64, odd: bool) f64 {
222	222	r = y + z * (s * (r + v) + y) + s * T[0];
223	223	w = x + r;
224	224	if (big) {
225		s = 1 - 2 * @as(f64, @floatFromInt(@intFromBool(odd)));
	225	s = @floatFromInt(1 - 2 * @as(i3, @intFromBool(odd)));
226	226	v = s - 2.0 * (x + (r - w * w / (w + s)));
227	227	return if (sign) -v else v;
228	228	}

src/arch/x86_64/CodeGen.zig+4480-422

...	...	@@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2414	2414	}
2415	2415
2416	2416	fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2417		@setEvalBranchQuota(9_600);
	2417	@setEvalBranchQuota(9_800);
2418	2418	const pt = cg.pt;
2419	2419	const zcu = pt.zcu;
2420	2420	const ip = &zcu.intern_pool;
...	...	@@ -2477,8 +2477,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2477	2477	.is_null => try cg.airIsNull(inst),
2478	2478	.is_non_err => try cg.airIsNonErr(inst),
2479	2479	.is_err => try cg.airIsErr(inst),
2480		.float_from_int => try cg.airFloatFromInt(inst),
2481		.int_from_float => try cg.airIntFromFloat(inst),
2482	2480	.cmpxchg_strong => try cg.airCmpxchg(inst),
2483	2481	.cmpxchg_weak => try cg.airCmpxchg(inst),
2484	2482	.atomic_rmw => try cg.airAtomicRmw(inst),
...	...	@@ -2522,7 +2520,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2522	2520	=> return cg.fail("TODO implement safety_checked_instructions", .{}),
2523	2521
2524	2522	.reduce_optimized => try cg.airReduce(inst),
2525		.int_from_float_optimized => try cg.airIntFromFloat(inst),
2526	2523
2527	2524	.arg => if (cg.debug_output != .none) {
2528	2525	// skip zero-bit arguments as they don't have a corresponding arg instruction
...	...	@@ -3018,7 +3015,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
3018	3015	.any,
3019	3016	},
3020	3017	.patterns = &.{
3021		.{ .src = .{ .mem, .mem, .none } },
	3018	.{ .src = .{ .to_mem, .to_mem, .none } },
3022	3019	},
3023	3020	.extra_temps = .{
3024	3021	.{ .type = .f64, .kind = .{ .reg = .st6 } },
...	...	@@ -3034,8 +3031,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
3034	3031	.dst_temps = .{.mem},
3035	3032	.each = .{ .once = &.{
3036	3033	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
3037		.{ ._, .f_, .ld, .src1q, ._, ._, ._ },
3038		.{ ._, .f_p, .add, ._, ._, ._, ._ },
	3034	.{ ._, .f_, .add, .src1q, ._, ._, ._ },
3039	3035	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
3040	3036	} },
3041	3037	}, .{
...	...	@@ -3173,8 +3169,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
3173	3169	.each = .{ .once = &.{
3174	3170	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
3175	3171	.{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
3176		.{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
3177		.{ ._, .f_p, .add, ._, ._, ._, ._ },
	3172	.{ ._, .f_, .add, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
3178	3173	.{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
3179	3174	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
3180	3175	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
...	...	@@ -3877,7 +3872,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
3877	3872	.any,
3878	3873	},
3879	3874	.patterns = &.{
3880		.{ .src = .{ .mem, .mem, .none } },
	3875	.{ .src = .{ .to_mem, .to_mem, .none } },
3881	3876	},
3882	3877	.extra_temps = .{
3883	3878	.{ .type = .f64, .kind = .{ .reg = .st6 } },
...	...	@@ -3893,8 +3888,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
3893	3888	.dst_temps = .{.mem},
3894	3889	.each = .{ .once = &.{
3895	3890	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
3896		.{ ._, .f_, .ld, .src1q, ._, ._, ._ },
3897		.{ ._, .f_p, .sub, ._, ._, ._, ._ },
	3891	.{ ._, .f_, .sub, .src1q, ._, ._, ._ },
3898	3892	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
3899	3893	} },
3900	3894	}, .{
...	...	@@ -4029,8 +4023,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
4029	4023	.each = .{ .once = &.{
4030	4024	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
4031	4025	.{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
4032		.{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
4033		.{ ._, .f_p, .sub, ._, ._, ._, ._ },
	4026	.{ ._, .f_, .sub, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
4034	4027	.{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
4035	4028	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
4036	4029	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
...	...	@@ -4782,8 +4775,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
4782	4775	.dst_temps = .{.mem},
4783	4776	.each = .{ .once = &.{
4784	4777	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
4785		.{ ._, .f_, .ld, .src1q, ._, ._, ._ },
4786		.{ ._, .f_p, .mul, ._, ._, ._, ._ },
	4778	.{ ._, .f_, .mul, .src1q, ._, ._, ._ },
4787	4779	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
4788	4780	} },
4789	4781	}, .{
...	...	@@ -4921,8 +4913,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
4921	4913	.each = .{ .once = &.{
4922	4914	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
4923	4915	.{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
4924		.{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
4925		.{ ._, .f_p, .mul, ._, ._, ._, ._ },
	4916	.{ ._, .f_, .mul, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
4926	4917	.{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
4927	4918	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
4928	4919	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
...	...	@@ -5645,8 +5636,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
5645	5636	.dst_temps = .{.mem},
5646	5637	.each = .{ .once = &.{
5647	5638	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
5648		.{ ._, .f_, .ld, .src1q, ._, ._, ._ },
5649		.{ ._, .f_p, .div, ._, ._, ._, ._ },
	5639	.{ ._, .f_, .div, .src1q, ._, ._, ._ },
5650	5640	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
5651	5641	} },
5652	5642	}, .{
...	...	@@ -5781,8 +5771,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
5781	5771	.each = .{ .once = &.{
5782	5772	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
5783	5773	.{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
5784		.{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
5785		.{ ._, .f_p, .div, ._, ._, ._, ._ },
	5774	.{ ._, .f_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
5786	5775	.{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
5787	5776	.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
5788	5777	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
...	...	@@ -6920,7 +6909,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
6920	6909	.any,
6921	6910	},
6922	6911	.patterns = &.{
6923		.{ .src = .{ .mem, .mem, .none } },
	6912	.{ .src = .{ .to_mem, .to_mem, .none } },
6924	6913	},
6925	6914	.call_frame = .{ .size = 16, .alignment = .@"16" },
6926	6915	.extra_temps = .{
...	...	@@ -8056,7 +8045,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
8056	8045	.any,
8057	8046	},
8058	8047	.patterns = &.{
8059		.{ .src = .{ .mem, .mem, .none } },
	8048	.{ .src = .{ .to_mem, .to_mem, .none } },
8060	8049	},
8061	8050	.call_frame = .{ .size = 16, .alignment = .@"16" },
8062	8051	.extra_temps = .{
...	...	@@ -10066,8 +10055,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
10066	10055	.{ ._, ._, .cmp, .tmp4q, .tmp3q, ._, ._ },
10067	10056	.{ ._, ._na, .j, .@"0f", ._, ._, ._ },
10068	10057	.{ ._, .f_, .ld, .mem(.tmp2q), ._, ._, ._ },
10069		.{ ._, .f_, .ld, .mem(.tmp0q), ._, ._, ._ },
10070		.{ ._, .f_p, .add, ._, ._, ._, ._ },
	10058	.{ ._, .f_, .add, .mem(.tmp0q), ._, ._, ._ },
10071	10059	.{ ._, .f_p, .st, .mem(.tmp2q), ._, ._, ._ },
10072	10060	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
10073	10061	.{ ._, ._ps, .movl, .dst0x, .mem(.tmp2q), ._, ._ },
...	...	@@ -10197,8 +10185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
10197	10185	.{ ._, ._, .cmp, .tmp6q, .tmp4q, ._, ._ },
10198	10186	.{ ._, ._na, .j, .@"1f", ._, ._, ._ },
10199	10187	.{ ._, .f_, .ld, .mem(.tmp5q), ._, ._, ._ },
10200		.{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
10201		.{ ._, .f_p, .add, ._, ._, ._, ._ },
	10188	.{ ._, .f_, .add, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
10202	10189	.{ ._, .f_p, .st, .mem(.tmp5q), ._, ._, ._ },
10203	10190	.{ ._, ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
10204	10191	.{ ._, ._ps, .movl, .tmp1x, .mem(.tmp5q), ._, ._ },
...	...	@@ -42607,7 +42594,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
42607	42594	.clobbers = .{ .eflags = true },
42608	42595	.each = .{ .once = &.{
42609	42596	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
42610		.{ .@"0:", ._, .movsxd, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
	42597	.{ .@"0:", ._d, .movsx, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
42611	42598	.{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
42612	42599	.{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
42613	42600	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
...	...	@@ -42764,7 +42751,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
42764	42751	.each = .{ .once = &.{
42765	42752	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
42766	42753	.{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ },
42767		.{ .@"0:", ._, .movsxd, .tmp2q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
	42754	.{ .@"0:", ._d, .movsx, .tmp2q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
42768	42755	.{ ._, ._sq, .sto, ._, ._, ._, ._ },
42769	42756	.{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ },
42770	42757	.{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ },
...	...	@@ -48617,47 +48604,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
48617	48604	try ops[0].toPair(&len, cg);
48618	48605	try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg);
48619	48606	},
48620		.error_set_has_value => return cg.fail("TODO implement error_set_has_value", .{}),
48621		.union_init => if (use_old) try cg.airUnionInit(inst) else {
48622		const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
48623		const extra = cg.air.extraData(Air.UnionInit, ty_pl.payload).data;
48624		const union_ty = ty_pl.ty.toType();
48625		var ops = try cg.tempsFromOperands(inst, .{extra.init});
48626		var res = try cg.tempAllocMem(union_ty);
48627		const union_layout = union_ty.unionGetLayout(zcu);
48628		if (union_layout.tag_size > 0) {
48629		var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex(
48630		union_ty.unionTagTypeSafety(zcu).?,
48631		extra.field_index,
48632		));
48633		try res.write(&tag_temp, .{
48634		.disp = @intCast(union_layout.tagOffset()),
48635		}, cg);
48636		try tag_temp.die(cg);
48637		}
48638		try res.write(&ops[0], .{
48639		.disp = @intCast(union_layout.payloadOffset()),
48640		}, cg);
48641		try res.finish(inst, &.{extra.init}, &ops, cg);
48642		},
48643		.mul_add => \|air_tag\| if (use_old) try cg.airMulAdd(inst) else {
48644		const pl_op = air_datas[@intFromEnum(inst)].pl_op;
48645		const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data;
48646		var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs, pl_op.operand });
	48607	.int_from_float, .int_from_float_optimized => \|air_tag\| if (use_old) try cg.airIntFromFloat(inst) else fallback: {
	48608	const ty_op = air_datas[@intFromEnum(inst)].ty_op;
	48609	if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airIntFromFloat(inst);
	48610	var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
48647	48611	var res: [1]Temp = undefined;
48648		cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
48649		.required_features = .{ .fma, .f16c, null, null },
48650		.src_constraints = .{
48651		.{ .scalar_float = .{ .of = .word, .is = .word } },
48652		.{ .scalar_float = .{ .of = .word, .is = .word } },
48653		.{ .scalar_float = .{ .of = .word, .is = .word } },
48654		},
	48612	cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
	48613	.required_features = .{ .f16c, null, null, null },
	48614	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48615	.dst_constraints = .{.{ .int = .dword }},
48655	48616	.patterns = &.{
48656		.{ .src = .{ .to_sse, .to_sse, .to_sse } },
	48617	.{ .src = .{ .to_sse, .none, .none } },
48657	48618	},
48658	48619	.extra_temps = .{
48659		.{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
48660		.{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	48620	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
	48621	.unused,
48661	48622	.unused,
48662	48623	.unused,
48663	48624	.unused,
...	...	@@ -48666,27 +48627,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
48666	48627	.unused,
48667	48628	.unused,
48668	48629	},
48669		.dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }},
	48630	.dst_temps = .{.{ .rc = .general_purpose }},
48670	48631	.each = .{ .once = &.{
48671		.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
48672		.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
48673		.{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ },
48674		.{ ._, .v_ss, .fmadd213, .dst0x, .tmp0x, .tmp1d, ._ },
48675		.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	48632	.{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
	48633	.{ ._, .v_, .cvttss2si, .dst0d, .tmp0d, ._, ._ },
48676	48634	} },
48677	48635	}, .{
48678		.required_features = .{ .sse, null, null, null },
48679		.src_constraints = .{
48680		.{ .scalar_float = .{ .of = .word, .is = .word } },
48681		.{ .scalar_float = .{ .of = .word, .is = .word } },
48682		.{ .scalar_float = .{ .of = .word, .is = .word } },
48683		},
	48636	.required_features = .{ .@"64bit", .f16c, null, null },
	48637	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48638	.dst_constraints = .{.{ .signed_int = .qword }},
48684	48639	.patterns = &.{
48685		.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } },
	48640	.{ .src = .{ .to_sse, .none, .none } },
48686	48641	},
48687		.call_frame = .{ .alignment = .@"16" },
48688	48642	.extra_temps = .{
48689		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	48643	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
48690	48644	.unused,
48691	48645	.unused,
48692	48646	.unused,
...	...	@@ -48696,31 +48650,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
48696	48650	.unused,
48697	48651	.unused,
48698	48652	},
48699		.dst_temps = .{.{ .ref = .src0 }},
48700		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	48653	.dst_temps = .{.{ .rc = .general_purpose }},
48701	48654	.each = .{ .once = &.{
48702		.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	48655	.{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
	48656	.{ ._, .v_, .cvttss2si, .dst0q, .tmp0d, ._, ._ },
48703	48657	} },
48704	48658	}, .{
48705		.required_features = .{ .fma, .f16c, null, null },
48706		.src_constraints = .{
48707		.{ .scalar_float = .{ .of = .qword, .is = .word } },
48708		.{ .scalar_float = .{ .of = .qword, .is = .word } },
48709		.{ .scalar_float = .{ .of = .qword, .is = .word } },
48710		},
	48659	.required_features = .{ .@"64bit", .f16c, null, null },
	48660	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48661	.dst_constraints = .{.{ .unsigned_int = .qword }},
48711	48662	.patterns = &.{
48712		.{ .src = .{ .mem, .mem, .mem } },
48713		.{ .src = .{ .to_sse, .mem, .mem } },
48714		.{ .src = .{ .mem, .to_sse, .mem } },
48715		.{ .src = .{ .mem, .mem, .to_sse } },
48716		.{ .src = .{ .to_sse, .to_sse, .mem } },
48717		.{ .src = .{ .to_sse, .mem, .to_sse } },
48718		.{ .src = .{ .mem, .to_sse, .to_sse } },
48719		.{ .src = .{ .to_sse, .to_sse, .to_sse } },
	48663	.{ .src = .{ .to_sse, .none, .none } },
48720	48664	},
48721	48665	.extra_temps = .{
48722		.{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
48723		.{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	48666	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
	48667	.unused,
48724	48668	.unused,
48725	48669	.unused,
48726	48670	.unused,
...	...	@@ -48729,34 +48673,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
48729	48673	.unused,
48730	48674	.unused,
48731	48675	},
48732		.dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }},
	48676	.dst_temps = .{.{ .rc = .general_purpose }},
48733	48677	.each = .{ .once = &.{
48734		.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
48735		.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
48736		.{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ },
48737		.{ ._, .v_ps, .fmadd213, .dst0x, .tmp0x, .tmp1x, ._ },
48738		.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	48678	.{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
	48679	.{ ._, .v_, .cvttss2si, .dst0d, .tmp0d, ._, ._ },
48739	48680	} },
48740	48681	}, .{
48741		.required_features = .{ .fma, .f16c, null, null },
48742		.src_constraints = .{
48743		.{ .scalar_float = .{ .of = .xword, .is = .word } },
48744		.{ .scalar_float = .{ .of = .xword, .is = .word } },
48745		.{ .scalar_float = .{ .of = .xword, .is = .word } },
48746		},
	48682	.required_features = .{ .@"64bit", .f16c, null, null },
	48683	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48684	.dst_constraints = .{.{ .signed_int = .xword }},
48747	48685	.patterns = &.{
48748		.{ .src = .{ .mem, .mem, .mem } },
48749		.{ .src = .{ .to_sse, .mem, .mem } },
48750		.{ .src = .{ .mem, .to_sse, .mem } },
48751		.{ .src = .{ .mem, .mem, .to_sse } },
48752		.{ .src = .{ .to_sse, .to_sse, .mem } },
48753		.{ .src = .{ .to_sse, .mem, .to_sse } },
48754		.{ .src = .{ .mem, .to_sse, .to_sse } },
48755		.{ .src = .{ .to_sse, .to_sse, .to_sse } },
	48686	.{ .src = .{ .to_sse, .none, .none } },
48756	48687	},
48757	48688	.extra_temps = .{
48758		.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
48759		.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	48689	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
	48690	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
48760	48691	.unused,
48761	48692	.unused,
48762	48693	.unused,
...	...	@@ -48765,29 +48696,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
48765	48696	.unused,
48766	48697	.unused,
48767	48698	},
48768		.dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }},
	48699	.dst_temps = .{.mem},
	48700	.clobbers = .{ .eflags = true },
48769	48701	.each = .{ .once = &.{
48770		.{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
48771		.{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
48772		.{ ._, .v_ps, .cvtph2, .tmp1y, .src2x, ._, ._ },
48773		.{ ._, .v_ps, .fmadd213, .dst0y, .tmp0y, .tmp1y, ._ },
48774		.{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
	48702	.{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
	48703	.{ ._, .v_, .cvttss2si, .tmp1q, .tmp0d, ._, ._ },
	48704	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	48705	.{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
	48706	.{ ._, ._, .mov, .memd(.dst0q, 8), .tmp1q, ._, ._ },
48775	48707	} },
48776	48708	}, .{
48777		.required_features = .{ .fma, .f16c, null, null },
48778		.src_constraints = .{
48779		.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
48780		.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
48781		.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
48782		},
	48709	.required_features = .{ .@"64bit", .f16c, null, null },
	48710	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48711	.dst_constraints = .{.{ .unsigned_int = .xword }},
48783	48712	.patterns = &.{
48784		.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	48713	.{ .src = .{ .to_sse, .none, .none } },
48785	48714	},
48786	48715	.extra_temps = .{
48787		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
48788		.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
48789		.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
48790		.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	48716	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
	48717	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
	48718	.unused,
	48719	.unused,
48791	48720	.unused,
48792	48721	.unused,
48793	48722	.unused,
...	...	@@ -48796,230 +48725,199 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
48796	48725	},
48797	48726	.dst_temps = .{.mem},
48798	48727	.each = .{ .once = &.{
48799		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
48800		.{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
48801		.{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
48802		.{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ },
48803		.{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .tmp3y, ._ },
48804		.{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
48805		.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
48806		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	48728	.{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
	48729	.{ ._, .v_, .cvttss2si, .tmp1q, .tmp0d, ._, ._ },
	48730	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	48731	.{ ._, ._, .mov, .memd(.dst0q, 8), .si(0), ._, ._ },
48807	48732	} },
48808	48733	}, .{
48809		.required_features = .{ .avx, null, null, null },
48810		.src_constraints = .{
48811		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48812		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48813		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48814		},
	48734	.required_features = .{ .@"64bit", .f16c, null, null },
	48735	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48736	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }},
48815	48737	.patterns = &.{
48816		.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	48738	.{ .src = .{ .to_sse, .none, .none } },
48817	48739	},
48818		.call_frame = .{ .alignment = .@"16" },
48819	48740	.extra_temps = .{
48820		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
48821		.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
48822		.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
48823		.{ .type = .f16, .kind = .{ .reg = .xmm2 } },
48824		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	48741	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
	48742	.{ .type = .i64, .kind = .{ .reg = .rax } },
	48743	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	48744	.{ .type = .u32, .kind = .{ .reg = .ecx } },
	48745	.unused,
48825	48746	.unused,
48826	48747	.unused,
48827	48748	.unused,
48828	48749	.unused,
48829	48750	},
48830	48751	.dst_temps = .{.mem},
48831		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	48752	.clobbers = .{ .eflags = true },
48832	48753	.each = .{ .once = &.{
48833		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
48834		.{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ },
48835		.{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
48836		.{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
48837		.{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0) },
48838		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
48839		.{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
48840		.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
48841		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	48754	.{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
	48755	.{ ._, .v_, .cvttss2si, .tmp1q, .tmp0d, ._, ._ },
	48756	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	48757	.{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
	48758	.{ ._, ._, .lea, .tmp2p, .memd(.dst0, 8), ._, ._ },
	48759	.{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
	48760	.{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
48842	48761	} },
48843	48762	}, .{
48844		.required_features = .{ .sse4_1, null, null, null },
48845		.src_constraints = .{
48846		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48847		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48848		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48849		},
	48763	.required_features = .{ .@"64bit", .f16c, null, null },
	48764	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48765	.dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }},
48850	48766	.patterns = &.{
48851		.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	48767	.{ .src = .{ .to_sse, .none, .none } },
48852	48768	},
48853		.call_frame = .{ .alignment = .@"16" },
48854	48769	.extra_temps = .{
48855		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
48856		.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
48857		.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
48858		.{ .type = .f16, .kind = .{ .reg = .xmm2 } },
48859		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	48770	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
	48771	.{ .type = .i64, .kind = .{ .reg = .rax } },
	48772	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	48773	.{ .type = .u32, .kind = .{ .reg = .ecx } },
	48774	.unused,
48860	48775	.unused,
48861	48776	.unused,
48862	48777	.unused,
48863	48778	.unused,
48864	48779	},
48865	48780	.dst_temps = .{.mem},
48866		.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	48781	.clobbers = .{ .eflags = true },
48867	48782	.each = .{ .once = &.{
48868		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
48869		.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
48870		.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
48871		.{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
48872		.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
48873		.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
48874		.{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ },
48875		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
48876		.{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
48877		.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
48878		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	48783	.{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ },
	48784	.{ ._, .v_, .cvttss2si, .tmp1q, .tmp0d, ._, ._ },
	48785	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	48786	.{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
	48787	.{ ._, ._, .lea, .tmp2p, .memd(.dst0, 8), ._, ._ },
	48788	.{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
	48789	.{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
48879	48790	} },
48880	48791	}, .{
48881		.required_features = .{ .sse2, null, null, null },
48882		.src_constraints = .{
48883		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48884		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48885		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48886		},
	48792	.required_features = .{ .sse, null, null, null },
	48793	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48794	.dst_constraints = .{.{ .signed_int = .dword }},
48887	48795	.patterns = &.{
48888		.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	48796	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
48889	48797	},
48890	48798	.call_frame = .{ .alignment = .@"16" },
48891	48799	.extra_temps = .{
48892		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
48893		.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
48894		.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
48895		.{ .type = .f16, .kind = .{ .reg = .xmm2 } },
48896		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
48897		.{ .type = .f16, .kind = .{ .reg = .ax } },
	48800	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } },
	48801	.unused,
	48802	.unused,
	48803	.unused,
	48804	.unused,
	48805	.unused,
48898	48806	.unused,
48899	48807	.unused,
48900	48808	.unused,
48901	48809	},
48902		.dst_temps = .{.mem},
	48810	.dst_temps = .{.{ .reg = .eax }},
48903	48811	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
48904	48812	.each = .{ .once = &.{
48905		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
48906		.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
48907		.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
48908		.{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
48909		.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
48910		.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
48911		.{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ },
48912		.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
48913		.{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
48914		.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
48915		.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
48916		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	48813	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
48917	48814	} },
48918	48815	}, .{
48919	48816	.required_features = .{ .sse, null, null, null },
48920		.src_constraints = .{
48921		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48922		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48923		.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
48924		},
	48817	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48818	.dst_constraints = .{.{ .unsigned_int = .dword }},
48925	48819	.patterns = &.{
48926		.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	48820	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
48927	48821	},
48928	48822	.call_frame = .{ .alignment = .@"16" },
48929	48823	.extra_temps = .{
48930		.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
48931		.{ .type = .f16, .kind = .{ .reg = .ax } },
48932		.{ .type = .f32, .kind = .mem },
48933		.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
48934		.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
48935		.{ .type = .f16, .kind = .{ .reg = .xmm2 } },
48936		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	48824	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfsi" } } },
	48825	.unused,
	48826	.unused,
	48827	.unused,
	48828	.unused,
	48829	.unused,
	48830	.unused,
48937	48831	.unused,
48938	48832	.unused,
48939	48833	},
48940		.dst_temps = .{.mem},
	48834	.dst_temps = .{.{ .reg = .eax }},
48941	48835	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
48942	48836	.each = .{ .once = &.{
48943		.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
48944		.{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
48945		.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
48946		.{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
48947		.{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
48948		.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
48949		.{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
48950		.{ ._, ._, .movzx, .tmp1d, .memia(.src2w, .tmp0, .add_unaligned_size), ._, ._ },
48951		.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
48952		.{ ._, ._ss, .mov, .tmp5x, .mem(.tmp2d), ._, ._ },
48953		.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
48954		.{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
48955		.{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
48956		.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
48957		.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
48958		.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	48837	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
48959	48838	} },
48960	48839	}, .{
48961		.required_features = .{ .fma, null, null, null },
48962		.src_constraints = .{
48963		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
48964		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
48965		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
48966		},
	48840	.required_features = .{ .@"64bit", .sse, null, null },
	48841	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48842	.dst_constraints = .{.{ .signed_int = .qword }},
48967	48843	.patterns = &.{
48968		.{ .src = .{ .to_mut_sse, .mem, .to_sse } },
48969		.{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
48970		.{ .src = .{ .mut_sse, .sse, .sse } },
48971		.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	48844	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
48972	48845	},
48973		.dst_temps = .{.{ .ref = .src0 }},
	48846	.call_frame = .{ .alignment = .@"16" },
	48847	.extra_temps = .{
	48848	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfdi" } } },
	48849	.unused,
	48850	.unused,
	48851	.unused,
	48852	.unused,
	48853	.unused,
	48854	.unused,
	48855	.unused,
	48856	.unused,
	48857	},
	48858	.dst_temps = .{.{ .reg = .rax }},
	48859	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
48974	48860	.each = .{ .once = &.{
48975		.{ ._, .v_ss, .fmadd132, .dst0x, .src2x, .src1d, ._ },
	48861	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
48976	48862	} },
48977	48863	}, .{
48978		.required_features = .{ .fma, null, null, null },
48979		.src_constraints = .{
48980		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
48981		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
48982		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
48983		},
	48864	.required_features = .{ .@"64bit", .sse, null, null },
	48865	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48866	.dst_constraints = .{.{ .unsigned_int = .qword }},
48984	48867	.patterns = &.{
48985		.{ .src = .{ .to_mut_sse, .to_sse, .mem } },
48986		.{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
48987		.{ .src = .{ .mut_sse, .sse, .sse } },
48988		.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	48868	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
48989	48869	},
48990		.dst_temps = .{.{ .ref = .src0 }},
	48870	.call_frame = .{ .alignment = .@"16" },
	48871	.extra_temps = .{
	48872	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfdi" } } },
	48873	.unused,
	48874	.unused,
	48875	.unused,
	48876	.unused,
	48877	.unused,
	48878	.unused,
	48879	.unused,
	48880	.unused,
	48881	},
	48882	.dst_temps = .{.{ .reg = .rax }},
	48883	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
48991	48884	.each = .{ .once = &.{
48992		.{ ._, .v_ss, .fmadd213, .dst0x, .src1x, .src2d, ._ },
	48885	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
48993	48886	} },
48994	48887	}, .{
48995		.required_features = .{ .fma, null, null, null },
48996		.src_constraints = .{
48997		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
48998		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
48999		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
49000		},
	48888	.required_features = .{ .@"64bit", .sse, null, null },
	48889	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48890	.dst_constraints = .{.{ .signed_int = .xword }},
49001	48891	.patterns = &.{
49002		.{ .src = .{ .to_sse, .mem, .to_mut_sse } },
49003		.{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
49004		.{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
	48892	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
49005	48893	},
49006		.dst_temps = .{.{ .ref = .src2 }},
	48894	.call_frame = .{ .alignment = .@"16" },
	48895	.extra_temps = .{
	48896	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfti" } } },
	48897	.unused,
	48898	.unused,
	48899	.unused,
	48900	.unused,
	48901	.unused,
	48902	.unused,
	48903	.unused,
	48904	.unused,
	48905	},
	48906	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	48907	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
49007	48908	.each = .{ .once = &.{
49008		.{ ._, .v_ss, .fmadd231, .dst0x, .src0x, .src1d, ._ },
	48909	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
49009	48910	} },
49010	48911	}, .{
49011		.required_features = .{ .sse, null, null, null },
49012		.src_constraints = .{
49013		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
49014		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
49015		.{ .scalar_float = .{ .of = .dword, .is = .dword } },
49016		},
	48912	.required_features = .{ .@"64bit", .sse, null, null },
	48913	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48914	.dst_constraints = .{.{ .unsigned_int = .xword }},
49017	48915	.patterns = &.{
49018		.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } },
	48916	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
49019	48917	},
49020	48918	.call_frame = .{ .alignment = .@"16" },
49021	48919	.extra_temps = .{
49022		.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaf" } } },
	48920	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfti" } } },
49023	48921	.unused,
49024	48922	.unused,
49025	48923	.unused,
...	...	@@ -49029,92 +48927,4158 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
49029	48927	.unused,
49030	48928	.unused,
49031	48929	},
49032		.dst_temps = .{.{ .ref = .src0 }},
	48930	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
49033	48931	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
49034	48932	.each = .{ .once = &.{
49035	48933	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
49036	48934	} },
49037	48935	}, .{
49038		.required_features = .{ .fma, null, null, null },
49039		.src_constraints = .{
49040		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49041		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49042		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49043		},
	48936	.required_features = .{ .@"64bit", .sse, null, null },
	48937	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48938	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }},
49044	48939	.patterns = &.{
49045		.{ .src = .{ .to_mut_sse, .mem, .to_sse } },
49046		.{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
49047		.{ .src = .{ .mut_sse, .sse, .sse } },
49048		.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	48940	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
49049	48941	},
49050		.dst_temps = .{.{ .ref = .src0 }},
	48942	.call_frame = .{ .alignment = .@"16" },
	48943	.extra_temps = .{
	48944	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfdi" } } },
	48945	.{ .type = .i64, .kind = .{ .reg = .rax } },
	48946	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	48947	.{ .type = .u32, .kind = .{ .reg = .ecx } },
	48948	.unused,
	48949	.unused,
	48950	.unused,
	48951	.unused,
	48952	.unused,
	48953	},
	48954	.dst_temps = .{.mem},
	48955	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
49051	48956	.each = .{ .once = &.{
49052		.{ ._, .v_ps, .fmadd132, .dst0x, .src2x, .src1x, ._ },
	48957	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	48958	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	48959	.{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
	48960	.{ ._, ._, .lea, .tmp2p, .memd(.dst0, 8), ._, ._ },
	48961	.{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
	48962	.{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
49053	48963	} },
49054	48964	}, .{
49055		.required_features = .{ .fma, null, null, null },
49056		.src_constraints = .{
49057		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49058		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49059		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49060		},
	48965	.required_features = .{ .@"64bit", .sse, null, null },
	48966	.src_constraints = .{ .{ .float = .word }, .any, .any },
	48967	.dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }},
49061	48968	.patterns = &.{
49062		.{ .src = .{ .to_mut_sse, .to_sse, .mem } },
49063		.{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
49064		.{ .src = .{ .mut_sse, .sse, .sse } },
49065		.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	48969	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
49066	48970	},
49067		.dst_temps = .{.{ .ref = .src0 }},
	48971	.call_frame = .{ .alignment = .@"16" },
	48972	.extra_temps = .{
	48973	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfdi" } } },
	48974	.{ .type = .i64, .kind = .{ .reg = .rax } },
	48975	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	48976	.{ .type = .u32, .kind = .{ .reg = .ecx } },
	48977	.unused,
	48978	.unused,
	48979	.unused,
	48980	.unused,
	48981	.unused,
	48982	},
	48983	.dst_temps = .{.mem},
	48984	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
49068	48985	.each = .{ .once = &.{
49069		.{ ._, .v_ps, .fmadd213, .dst0x, .src1x, .src2x, ._ },
	48986	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	48987	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	48988	.{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
	48989	.{ ._, ._, .lea, .tmp2p, .memd(.dst0, 8), ._, ._ },
	48990	.{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_size_div_8), ._, ._ },
	48991	.{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
49070	48992	} },
49071	48993	}, .{
49072		.required_features = .{ .fma, null, null, null },
49073		.src_constraints = .{
49074		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49075		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49076		.{ .scalar_float = .{ .of = .xword, .is = .dword } },
49077		},
	48994	.required_features = .{ .avx, null, null, null },
	48995	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	48996	.dst_constraints = .{.{ .signed_or_exclusive_int = .dword }},
49078	48997	.patterns = &.{
49079		.{ .src = .{ .to_sse, .mem, .to_mut_sse } },
49080		.{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
49081		.{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
	48998	.{ .src = .{ .mem, .none, .none } },
	48999	.{ .src = .{ .to_sse, .none, .none } },
49082	49000	},
49083		.dst_temps = .{.{ .ref = .src2 }},
	49001	.dst_temps = .{.{ .rc = .general_purpose }},
49084	49002	.each = .{ .once = &.{
49085		.{ ._, .v_ps, .fmadd231, .dst0x, .src0x, .src1x, ._ },
	49003	.{ ._, .v_, .cvttss2si, .dst0d, .src0d, ._, ._ },
49086	49004	} },
49087	49005	}, .{
49088		.required_features = .{ .fma, null, null, null },
49089		.src_constraints = .{
49090		.{ .scalar_float = .{ .of = .yword, .is = .dword } },
49091		.{ .scalar_float = .{ .of = .yword, .is = .dword } },
49092		.{ .scalar_float = .{ .of = .yword, .is = .dword } },
49093		},
	49006	.required_features = .{ .sse, null, null, null },
	49007	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49008	.dst_constraints = .{.{ .signed_or_exclusive_int = .dword }},
49094	49009	.patterns = &.{
49095		.{ .src = .{ .to_mut_sse, .mem, .to_sse } },
49096		.{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
49097		.{ .src = .{ .mut_sse, .sse, .sse } },
49098		.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	49010	.{ .src = .{ .mem, .none, .none } },
	49011	.{ .src = .{ .to_sse, .none, .none } },
49099	49012	},
49100		.dst_temps = .{.{ .ref = .src0 }},
	49013	.dst_temps = .{.{ .rc = .general_purpose }},
49101	49014	.each = .{ .once = &.{
49102		.{ ._, .v_ps, .fmadd132, .dst0y, .src2y, .src1y, ._ },
	49015	.{ ._, ._, .cvttss2si, .dst0d, .src0d, ._, ._ },
49103	49016	} },
49104	49017	}, .{
49105		.required_features = .{ .fma, null, null, null },
49106		.src_constraints = .{
49107		.{ .scalar_float = .{ .of = .yword, .is = .dword } },
49108		.{ .scalar_float = .{ .of = .yword, .is = .dword } },
49109		.{ .scalar_float = .{ .of = .yword, .is = .dword } },
49110		},
	49018	.required_features = .{ .@"64bit", .avx, null, null },
	49019	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49020	.dst_constraints = .{.{ .signed_or_exclusive_int = .qword }},
49111	49021	.patterns = &.{
49112		.{ .src = .{ .to_mut_sse, .to_sse, .mem } },
49113		.{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
49114		.{ .src = .{ .mut_sse, .sse, .sse } },
49115		.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	49022	.{ .src = .{ .mem, .none, .none } },
	49023	.{ .src = .{ .to_sse, .none, .none } },
49116	49024	},
49117		.dst_temps = .{.{ .ref = .src0 }},
	49025	.dst_temps = .{.{ .rc = .general_purpose }},
	49026	.each = .{ .once = &.{
	49027	.{ ._, .v_, .cvttss2si, .dst0q, .src0d, ._, ._ },
	49028	} },
	49029	}, .{
	49030	.required_features = .{ .@"64bit", .sse, null, null },
	49031	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49032	.dst_constraints = .{.{ .signed_or_exclusive_int = .qword }},
	49033	.patterns = &.{
	49034	.{ .src = .{ .mem, .none, .none } },
	49035	.{ .src = .{ .to_sse, .none, .none } },
	49036	},
	49037	.dst_temps = .{.{ .rc = .general_purpose }},
	49038	.each = .{ .once = &.{
	49039	.{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ },
	49040	} },
	49041	}, .{
	49042	.required_features = .{ .@"64bit", .avx, null, null },
	49043	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49044	.dst_constraints = .{.{ .exact_unsigned_int = 64 }},
	49045	.patterns = &.{
	49046	.{ .src = .{ .to_sse, .none, .none } },
	49047	},
	49048	.extra_temps = .{
	49049	.{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
	49050	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49051	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49052	.{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
	49053	.unused,
	49054	.unused,
	49055	.unused,
	49056	.unused,
	49057	.unused,
	49058	},
	49059	.dst_temps = .{.{ .rc = .general_purpose }},
	49060	.clobbers = .{ .eflags = true },
	49061	.each = .{ .once = &.{
	49062	.{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
	49063	.{ ._, .v_, .cvttss2si, .tmp2q, .src0d, ._, ._ },
	49064	.{ ._, .v_ss, .sub, .tmp0x, .src0x, .lea(.tmp1d), ._ },
	49065	.{ ._, .v_, .cvttss2si, .dst0q, .tmp0d, ._, ._ },
	49066	.{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ },
	49067	.{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
	49068	.{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ },
	49069	.{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ },
	49070	} },
	49071	}, .{
	49072	.required_features = .{ .@"64bit", .sse, null, null },
	49073	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49074	.dst_constraints = .{.{ .exact_unsigned_int = 64 }},
	49075	.patterns = &.{
	49076	.{ .src = .{ .to_mut_sse, .none, .none } },
	49077	},
	49078	.extra_temps = .{
	49079	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49080	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49081	.{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
	49082	.unused,
	49083	.unused,
	49084	.unused,
	49085	.unused,
	49086	.unused,
	49087	.unused,
	49088	},
	49089	.dst_temps = .{.{ .rc = .general_purpose }},
	49090	.clobbers = .{ .eflags = true },
	49091	.each = .{ .once = &.{
	49092	.{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
	49093	.{ ._, ._, .cvttss2si, .tmp1q, .src0d, ._, ._ },
	49094	.{ ._, ._ss, .sub, .src0x, .lea(.tmp0d), ._, ._ },
	49095	.{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ },
	49096	.{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
	49097	.{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
	49098	.{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
	49099	.{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
	49100	} },
	49101	}, .{
	49102	.required_features = .{ .@"64bit", .sse, null, null },
	49103	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49104	.dst_constraints = .{.{ .signed_int = .xword }},
	49105	.patterns = &.{
	49106	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49107	},
	49108	.call_frame = .{ .alignment = .@"16" },
	49109	.extra_temps = .{
	49110	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfti" } } },
	49111	.unused,
	49112	.unused,
	49113	.unused,
	49114	.unused,
	49115	.unused,
	49116	.unused,
	49117	.unused,
	49118	.unused,
	49119	},
	49120	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49121	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49122	.each = .{ .once = &.{
	49123	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	49124	} },
	49125	}, .{
	49126	.required_features = .{ .@"64bit", .sse, null, null },
	49127	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49128	.dst_constraints = .{.{ .unsigned_int = .xword }},
	49129	.patterns = &.{
	49130	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49131	},
	49132	.call_frame = .{ .alignment = .@"16" },
	49133	.extra_temps = .{
	49134	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } },
	49135	.unused,
	49136	.unused,
	49137	.unused,
	49138	.unused,
	49139	.unused,
	49140	.unused,
	49141	.unused,
	49142	.unused,
	49143	},
	49144	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49145	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49146	.each = .{ .once = &.{
	49147	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	49148	} },
	49149	}, .{
	49150	.required_features = .{ .@"64bit", .avx, null, null },
	49151	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49152	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }},
	49153	.patterns = &.{
	49154	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49155	},
	49156	.call_frame = .{ .alignment = .@"16" },
	49157	.extra_temps = .{
	49158	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49159	.{ .type = .i64, .kind = .{ .reg = .rax } },
	49160	.{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
	49161	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } },
	49162	.{ .type = .i64, .kind = .{ .reg = .rdx } },
	49163	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	49164	.{ .type = .u32, .kind = .{ .reg = .ecx } },
	49165	.unused,
	49166	.unused,
	49167	},
	49168	.dst_temps = .{.mem},
	49169	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49170	.each = .{ .once = &.{
	49171	.{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ },
	49172	.{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
	49173	.{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
	49174	.{ ._, .v_ps, .@"and", .src0x, .src0x, .lea(.tmp1x), ._ },
	49175	.{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
	49176	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	49177	.{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
	49178	.{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
	49179	.{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
	49180	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	49181	.{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
	49182	.{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
	49183	.{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
	49184	.{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
	49185	.{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
	49186	.{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
	49187	} },
	49188	}, .{
	49189	.required_features = .{ .@"64bit", .sse2, null, null },
	49190	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49191	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }},
	49192	.patterns = &.{
	49193	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49194	},
	49195	.call_frame = .{ .alignment = .@"16" },
	49196	.extra_temps = .{
	49197	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49198	.{ .type = .i64, .kind = .{ .reg = .rax } },
	49199	.{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
	49200	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } },
	49201	.{ .type = .i64, .kind = .{ .reg = .rdx } },
	49202	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	49203	.{ .type = .u32, .kind = .{ .reg = .ecx } },
	49204	.unused,
	49205	.unused,
	49206	},
	49207	.dst_temps = .{.mem},
	49208	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49209	.each = .{ .once = &.{
	49210	.{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ },
	49211	.{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
	49212	.{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ },
	49213	.{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ },
	49214	.{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ },
	49215	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	49216	.{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ },
	49217	.{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ },
	49218	.{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ },
	49219	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	49220	.{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ },
	49221	.{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ },
	49222	.{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
	49223	.{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ },
	49224	.{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
	49225	.{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
	49226	} },
	49227	}, .{
	49228	.required_features = .{ .@"64bit", .sse, null, null },
	49229	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49230	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }},
	49231	.patterns = &.{
	49232	.{ .src = .{ .to_mem, .none, .none } },
	49233	},
	49234	.call_frame = .{ .alignment = .@"16" },
	49235	.extra_temps = .{
	49236	.{ .type = .f32, .kind = .{ .reg = .xmm0 } },
	49237	.{ .type = .i64, .kind = .{ .reg = .rax } },
	49238	.{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } },
	49239	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } },
	49240	.{ .type = .u32, .kind = .{ .reg = .ecx } },
	49241	.{ .type = .i64, .kind = .{ .reg = .rdx } },
	49242	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	49243	.unused,
	49244	.unused,
	49245	},
	49246	.dst_temps = .{.mem},
	49247	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49248	.each = .{ .once = &.{
	49249	.{ ._, ._ss, .mov, .tmp0x, .src0d, ._, ._ },
	49250	.{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
	49251	.{ ._, ._ps, .@"and", .tmp0x, .lea(.tmp1x), ._, ._ },
	49252	.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
	49253	.{ ._, ._d, .movsx, .tmp4q, .src0d, ._, ._ },
	49254	.{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ },
	49255	.{ ._, ._, .xor, .tmp1q, .tmp4q, ._, ._ },
	49256	.{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ },
	49257	.{ ._, ._, .sub, .tmp1q, .tmp4q, ._, ._ },
	49258	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	49259	.{ ._, ._, .sbb, .tmp5q, .tmp4q, ._, ._ },
	49260	.{ ._, ._, .mov, .memd(.dst0q, 8), .tmp5q, ._, ._ },
	49261	.{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ },
	49262	.{ ._, ._, .lea, .tmp6p, .memd(.dst0, 16), ._, ._ },
	49263	.{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
	49264	.{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
	49265	} },
	49266	}, .{
	49267	.required_features = .{ .@"64bit", .sse, null, null },
	49268	.src_constraints = .{ .{ .float = .dword }, .any, .any },
	49269	.dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }},
	49270	.patterns = &.{
	49271	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49272	},
	49273	.call_frame = .{ .alignment = .@"16" },
	49274	.extra_temps = .{
	49275	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } },
	49276	.{ .type = .i64, .kind = .{ .reg = .rax } },
	49277	.{ .type = .i64, .kind = .{ .reg = .rdx } },
	49278	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	49279	.{ .type = .u32, .kind = .{ .reg = .ecx } },
	49280	.unused,
	49281	.unused,
	49282	.unused,
	49283	.unused,
	49284	},
	49285	.dst_temps = .{.mem},
	49286	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49287	.each = .{ .once = &.{
	49288	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	49289	.{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ },
	49290	.{ ._, ._, .mov, .memd(.dst0q, 8), .tmp2q, ._, ._ },
	49291	.{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ },
	49292	.{ ._, ._, .lea, .tmp3p, .memd(.dst0, 16), ._, ._ },
	49293	.{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ },
	49294	.{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ },
	49295	} },
	49296	}, .{
	49297	.required_features = .{ .avx, null, null, null },
	49298	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49299	.dst_constraints = .{.{ .signed_or_exclusive_int = .dword }},
	49300	.patterns = &.{
	49301	.{ .src = .{ .mem, .none, .none } },
	49302	.{ .src = .{ .to_sse, .none, .none } },
	49303	},
	49304	.dst_temps = .{.{ .rc = .general_purpose }},
	49305	.each = .{ .once = &.{
	49306	.{ ._, .v_, .cvttsd2si, .dst0d, .src0q, ._, ._ },
	49307	} },
	49308	}, .{
	49309	.required_features = .{ .sse2, null, null, null },
	49310	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49311	.dst_constraints = .{.{ .signed_or_exclusive_int = .dword }},
	49312	.patterns = &.{
	49313	.{ .src = .{ .mem, .none, .none } },
	49314	.{ .src = .{ .to_sse, .none, .none } },
	49315	},
	49316	.dst_temps = .{.{ .rc = .general_purpose }},
	49317	.each = .{ .once = &.{
	49318	.{ ._, ._, .cvttsd2si, .dst0d, .src0q, ._, ._ },
	49319	} },
	49320	}, .{
	49321	.required_features = .{ .x87, null, null, null },
	49322	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49323	.dst_constraints = .{.{ .signed_int = .byte }},
	49324	.patterns = &.{
	49325	.{ .src = .{ .to_mem, .none, .none } },
	49326	},
	49327	.extra_temps = .{
	49328	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49329	.{ .type = .i16, .kind = .mem },
	49330	.unused,
	49331	.unused,
	49332	.unused,
	49333	.unused,
	49334	.unused,
	49335	.unused,
	49336	.unused,
	49337	},
	49338	.dst_temps = .{.{ .rc = .general_purpose }},
	49339	.each = .{ .once = &.{
	49340	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
	49341	.{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ },
	49342	.{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ },
	49343	} },
	49344	}, .{
	49345	.required_features = .{ .x87, null, null, null },
	49346	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49347	.dst_constraints = .{.{ .unsigned_int = .byte }},
	49348	.patterns = &.{
	49349	.{ .src = .{ .to_mem, .none, .none } },
	49350	},
	49351	.extra_temps = .{
	49352	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49353	.{ .type = .i16, .kind = .mem },
	49354	.unused,
	49355	.unused,
	49356	.unused,
	49357	.unused,
	49358	.unused,
	49359	.unused,
	49360	.unused,
	49361	},
	49362	.dst_temps = .{.{ .rc = .general_purpose }},
	49363	.each = .{ .once = &.{
	49364	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
	49365	.{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ },
	49366	.{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ },
	49367	} },
	49368	}, .{
	49369	.required_features = .{ .x87, null, null, null },
	49370	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49371	.dst_constraints = .{.{ .signed_or_exclusive_int = .word }},
	49372	.patterns = &.{
	49373	.{ .src = .{ .to_mem, .none, .none } },
	49374	},
	49375	.extra_temps = .{
	49376	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49377	.unused,
	49378	.unused,
	49379	.unused,
	49380	.unused,
	49381	.unused,
	49382	.unused,
	49383	.unused,
	49384	.unused,
	49385	},
	49386	.dst_temps = .{.mem},
	49387	.each = .{ .once = &.{
	49388	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
	49389	.{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ },
	49390	} },
	49391	}, .{
	49392	.required_features = .{ .x87, null, null, null },
	49393	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49394	.dst_constraints = .{.{ .signed_or_exclusive_int = .dword }},
	49395	.patterns = &.{
	49396	.{ .src = .{ .to_mem, .none, .none } },
	49397	},
	49398	.extra_temps = .{
	49399	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49400	.unused,
	49401	.unused,
	49402	.unused,
	49403	.unused,
	49404	.unused,
	49405	.unused,
	49406	.unused,
	49407	.unused,
	49408	},
	49409	.dst_temps = .{.mem},
	49410	.each = .{ .once = &.{
	49411	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
	49412	.{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ },
	49413	} },
	49414	}, .{
	49415	.required_features = .{ .@"64bit", .avx, null, null },
	49416	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49417	.dst_constraints = .{.{ .signed_or_exclusive_int = .qword }},
	49418	.patterns = &.{
	49419	.{ .src = .{ .mem, .none, .none } },
	49420	.{ .src = .{ .to_sse, .none, .none } },
	49421	},
	49422	.dst_temps = .{.{ .rc = .general_purpose }},
	49423	.each = .{ .once = &.{
	49424	.{ ._, .v_, .cvttsd2si, .dst0q, .src0q, ._, ._ },
	49425	} },
	49426	}, .{
	49427	.required_features = .{ .@"64bit", .sse2, null, null },
	49428	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49429	.dst_constraints = .{.{ .signed_or_exclusive_int = .qword }},
	49430	.patterns = &.{
	49431	.{ .src = .{ .mem, .none, .none } },
	49432	.{ .src = .{ .to_sse, .none, .none } },
	49433	},
	49434	.dst_temps = .{.{ .rc = .general_purpose }},
	49435	.each = .{ .once = &.{
	49436	.{ ._, ._, .cvttsd2si, .dst0q, .src0q, ._, ._ },
	49437	} },
	49438	}, .{
	49439	.required_features = .{ .x87, null, null, null },
	49440	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49441	.dst_constraints = .{.{ .signed_or_exclusive_int = .qword }},
	49442	.patterns = &.{
	49443	.{ .src = .{ .to_mem, .none, .none } },
	49444	},
	49445	.extra_temps = .{
	49446	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49447	.unused,
	49448	.unused,
	49449	.unused,
	49450	.unused,
	49451	.unused,
	49452	.unused,
	49453	.unused,
	49454	.unused,
	49455	},
	49456	.dst_temps = .{.mem},
	49457	.each = .{ .once = &.{
	49458	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
	49459	.{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ },
	49460	} },
	49461	}, .{
	49462	.required_features = .{ .@"64bit", .avx, null, null },
	49463	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49464	.dst_constraints = .{.{ .exact_unsigned_int = 64 }},
	49465	.patterns = &.{
	49466	.{ .src = .{ .to_sse, .none, .none } },
	49467	},
	49468	.extra_temps = .{
	49469	.{ .type = .f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
	49470	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49471	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49472	.{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } },
	49473	.unused,
	49474	.unused,
	49475	.unused,
	49476	.unused,
	49477	.unused,
	49478	},
	49479	.dst_temps = .{.{ .rc = .general_purpose }},
	49480	.clobbers = .{ .eflags = true },
	49481	.each = .{ .once = &.{
	49482	.{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
	49483	.{ ._, .v_, .cvttsd2si, .tmp2q, .src0d, ._, ._ },
	49484	.{ ._, .v_sd, .sub, .tmp0x, .src0x, .lea(.tmp1q), ._ },
	49485	.{ ._, .v_, .cvttsd2si, .dst0q, .tmp0d, ._, ._ },
	49486	.{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ },
	49487	.{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ },
	49488	.{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ },
	49489	.{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ },
	49490	} },
	49491	}, .{
	49492	.required_features = .{ .@"64bit", .sse2, null, null },
	49493	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49494	.dst_constraints = .{.{ .exact_unsigned_int = 64 }},
	49495	.patterns = &.{
	49496	.{ .src = .{ .to_mut_sse, .none, .none } },
	49497	},
	49498	.extra_temps = .{
	49499	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49500	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49501	.{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } },
	49502	.unused,
	49503	.unused,
	49504	.unused,
	49505	.unused,
	49506	.unused,
	49507	.unused,
	49508	},
	49509	.dst_temps = .{.{ .rc = .general_purpose }},
	49510	.clobbers = .{ .eflags = true },
	49511	.each = .{ .once = &.{
	49512	.{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
	49513	.{ ._, ._, .cvttsd2si, .tmp1q, .src0d, ._, ._ },
	49514	.{ ._, ._sd, .sub, .src0x, .lea(.tmp0q), ._, ._ },
	49515	.{ ._, ._, .cvttsd2si, .dst0q, .src0d, ._, ._ },
	49516	.{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ },
	49517	.{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ },
	49518	.{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ },
	49519	.{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
	49520	} },
	49521	}, .{
	49522	.required_features = .{ .@"64bit", .x87, null, null },
	49523	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49524	.dst_constraints = .{.{ .exact_unsigned_int = 64 }},
	49525	.patterns = &.{
	49526	.{ .src = .{ .to_mem, .none, .none } },
	49527	},
	49528	.extra_temps = .{
	49529	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49530	.{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
	49531	.{ .type = .f64, .kind = .{ .reg = .st6 } },
	49532	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49533	.{ .type = .i64, .kind = .mem },
	49534	.unused,
	49535	.unused,
	49536	.unused,
	49537	.unused,
	49538	},
	49539	.dst_temps = .{.{ .rc = .general_purpose }},
	49540	.clobbers = .{ .eflags = true },
	49541	.each = .{ .once = &.{
	49542	.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
	49543	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
	49544	.{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
	49545	.{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ },
	49546	.{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ },
	49547	.{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ },
	49548	.{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
	49549	.{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ },
	49550	.{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
	49551	.{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ },
	49552	.{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
	49553	} },
	49554	}, .{
	49555	.required_features = .{ .@"64bit", .sse, null, null },
	49556	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49557	.dst_constraints = .{.{ .signed_int = .xword }},
	49558	.patterns = &.{
	49559	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49560	},
	49561	.call_frame = .{ .alignment = .@"16" },
	49562	.extra_temps = .{
	49563	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfti" } } },
	49564	.unused,
	49565	.unused,
	49566	.unused,
	49567	.unused,
	49568	.unused,
	49569	.unused,
	49570	.unused,
	49571	.unused,
	49572	},
	49573	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49574	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49575	.each = .{ .once = &.{
	49576	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	49577	} },
	49578	}, .{
	49579	.required_features = .{ .@"64bit", .sse, null, null },
	49580	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49581	.dst_constraints = .{.{ .unsigned_int = .xword }},
	49582	.patterns = &.{
	49583	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49584	},
	49585	.call_frame = .{ .alignment = .@"16" },
	49586	.extra_temps = .{
	49587	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfti" } } },
	49588	.unused,
	49589	.unused,
	49590	.unused,
	49591	.unused,
	49592	.unused,
	49593	.unused,
	49594	.unused,
	49595	.unused,
	49596	},
	49597	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49598	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49599	.each = .{ .once = &.{
	49600	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	49601	} },
	49602	}, .{
	49603	.required_features = .{ .@"64bit", .sse, null, null },
	49604	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49605	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }},
	49606	.patterns = &.{
	49607	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49608	},
	49609	.call_frame = .{ .alignment = .@"16" },
	49610	.extra_temps = .{
	49611	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	49612	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	49613	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfei" } } },
	49614	.unused,
	49615	.unused,
	49616	.unused,
	49617	.unused,
	49618	.unused,
	49619	.unused,
	49620	},
	49621	.dst_temps = .{.mem},
	49622	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49623	.each = .{ .once = &.{
	49624	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	49625	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	49626	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	49627	} },
	49628	}, .{
	49629	.required_features = .{ .@"64bit", .sse, null, null },
	49630	.src_constraints = .{ .{ .float = .qword }, .any, .any },
	49631	.dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }},
	49632	.patterns = &.{
	49633	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	49634	},
	49635	.call_frame = .{ .alignment = .@"16" },
	49636	.extra_temps = .{
	49637	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	49638	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	49639	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfei" } } },
	49640	.unused,
	49641	.unused,
	49642	.unused,
	49643	.unused,
	49644	.unused,
	49645	.unused,
	49646	},
	49647	.dst_temps = .{.mem},
	49648	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49649	.each = .{ .once = &.{
	49650	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	49651	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	49652	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	49653	} },
	49654	}, .{
	49655	.required_features = .{ .x87, null, null, null },
	49656	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49657	.dst_constraints = .{.{ .signed_int = .byte }},
	49658	.patterns = &.{
	49659	.{ .src = .{ .mem, .none, .none } },
	49660	.{ .src = .{ .to_x87, .none, .none } },
	49661	},
	49662	.extra_temps = .{
	49663	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49664	.{ .type = .i16, .kind = .mem },
	49665	.unused,
	49666	.unused,
	49667	.unused,
	49668	.unused,
	49669	.unused,
	49670	.unused,
	49671	.unused,
	49672	},
	49673	.dst_temps = .{.{ .rc = .general_purpose }},
	49674	.each = .{ .once = &.{
	49675	.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
	49676	.{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ },
	49677	.{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ },
	49678	} },
	49679	}, .{
	49680	.required_features = .{ .x87, null, null, null },
	49681	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49682	.dst_constraints = .{.{ .unsigned_int = .byte }},
	49683	.patterns = &.{
	49684	.{ .src = .{ .mem, .none, .none } },
	49685	.{ .src = .{ .to_x87, .none, .none } },
	49686	},
	49687	.extra_temps = .{
	49688	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49689	.{ .type = .i16, .kind = .mem },
	49690	.unused,
	49691	.unused,
	49692	.unused,
	49693	.unused,
	49694	.unused,
	49695	.unused,
	49696	.unused,
	49697	},
	49698	.dst_temps = .{.{ .rc = .general_purpose }},
	49699	.each = .{ .once = &.{
	49700	.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
	49701	.{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ },
	49702	.{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ },
	49703	} },
	49704	}, .{
	49705	.required_features = .{ .x87, null, null, null },
	49706	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49707	.dst_constraints = .{.{ .signed_or_exclusive_int = .word }},
	49708	.patterns = &.{
	49709	.{ .src = .{ .mem, .none, .none } },
	49710	.{ .src = .{ .to_x87, .none, .none } },
	49711	},
	49712	.extra_temps = .{
	49713	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	49714	.unused,
	49715	.unused,
	49716	.unused,
	49717	.unused,
	49718	.unused,
	49719	.unused,
	49720	.unused,
	49721	.unused,
	49722	},
	49723	.dst_temps = .{.mem},
	49724	.each = .{ .once = &.{
	49725	.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
	49726	.{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ },
	49727	} },
	49728	}, .{
	49729	.required_features = .{ .x87, null, null, null },
	49730	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49731	.dst_constraints = .{.{ .signed_or_exclusive_int = .dword }},
	49732	.patterns = &.{
	49733	.{ .src = .{ .mem, .none, .none } },
	49734	.{ .src = .{ .to_x87, .none, .none } },
	49735	},
	49736	.extra_temps = .{
	49737	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	49738	.unused,
	49739	.unused,
	49740	.unused,
	49741	.unused,
	49742	.unused,
	49743	.unused,
	49744	.unused,
	49745	.unused,
	49746	},
	49747	.dst_temps = .{.mem},
	49748	.each = .{ .once = &.{
	49749	.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
	49750	.{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ },
	49751	} },
	49752	}, .{
	49753	.required_features = .{ .x87, null, null, null },
	49754	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49755	.dst_constraints = .{.{ .signed_or_exclusive_int = .qword }},
	49756	.patterns = &.{
	49757	.{ .src = .{ .mem, .none, .none } },
	49758	.{ .src = .{ .to_x87, .none, .none } },
	49759	},
	49760	.extra_temps = .{
	49761	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	49762	.unused,
	49763	.unused,
	49764	.unused,
	49765	.unused,
	49766	.unused,
	49767	.unused,
	49768	.unused,
	49769	.unused,
	49770	},
	49771	.dst_temps = .{.mem},
	49772	.each = .{ .once = &.{
	49773	.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
	49774	.{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ },
	49775	} },
	49776	}, .{
	49777	.required_features = .{ .@"64bit", .x87, null, null },
	49778	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49779	.dst_constraints = .{.{ .exact_unsigned_int = 64 }},
	49780	.patterns = &.{
	49781	.{ .src = .{ .mem, .none, .none } },
	49782	.{ .src = .{ .to_x87, .none, .none } },
	49783	},
	49784	.extra_temps = .{
	49785	.{ .type = .i64, .kind = .{ .rc = .general_purpose } },
	49786	.{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } },
	49787	.{ .type = .f64, .kind = .{ .reg = .st6 } },
	49788	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	49789	.{ .type = .i64, .kind = .mem },
	49790	.unused,
	49791	.unused,
	49792	.unused,
	49793	.unused,
	49794	},
	49795	.dst_temps = .{.{ .rc = .general_purpose }},
	49796	.clobbers = .{ .eflags = true },
	49797	.each = .{ .once = &.{
	49798	.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
	49799	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
	49800	.{ ._, .f_, .ld, .tmp3t, ._, ._, ._ },
	49801	.{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ },
	49802	.{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ },
	49803	.{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ },
	49804	.{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ },
	49805	.{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ },
	49806	.{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ },
	49807	.{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ },
	49808	.{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ },
	49809	} },
	49810	}, .{
	49811	.required_features = .{ .@"64bit", .avx, null, null },
	49812	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49813	.dst_constraints = .{.{ .signed_int = .xword }},
	49814	.patterns = &.{
	49815	.{ .src = .{ .to_mem, .none, .none } },
	49816	},
	49817	.call_frame = .{ .size = 16, .alignment = .@"16" },
	49818	.extra_temps = .{
	49819	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	49820	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	49821	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } },
	49822	.unused,
	49823	.unused,
	49824	.unused,
	49825	.unused,
	49826	.unused,
	49827	.unused,
	49828	},
	49829	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49830	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49831	.each = .{ .once = &.{
	49832	.{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ },
	49833	.{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
	49834	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	49835	} },
	49836	}, .{
	49837	.required_features = .{ .@"64bit", .sse2, null, null },
	49838	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49839	.dst_constraints = .{.{ .signed_int = .xword }},
	49840	.patterns = &.{
	49841	.{ .src = .{ .to_mem, .none, .none } },
	49842	},
	49843	.call_frame = .{ .size = 16, .alignment = .@"16" },
	49844	.extra_temps = .{
	49845	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	49846	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	49847	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } },
	49848	.unused,
	49849	.unused,
	49850	.unused,
	49851	.unused,
	49852	.unused,
	49853	.unused,
	49854	},
	49855	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49856	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49857	.each = .{ .once = &.{
	49858	.{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
	49859	.{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
	49860	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	49861	} },
	49862	}, .{
	49863	.required_features = .{ .@"64bit", .sse, null, null },
	49864	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49865	.dst_constraints = .{.{ .signed_int = .xword }},
	49866	.patterns = &.{
	49867	.{ .src = .{ .to_mem, .none, .none } },
	49868	},
	49869	.call_frame = .{ .size = 16, .alignment = .@"16" },
	49870	.extra_temps = .{
	49871	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	49872	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	49873	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } },
	49874	.unused,
	49875	.unused,
	49876	.unused,
	49877	.unused,
	49878	.unused,
	49879	.unused,
	49880	},
	49881	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49882	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49883	.each = .{ .once = &.{
	49884	.{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
	49885	.{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ },
	49886	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	49887	} },
	49888	}, .{
	49889	.required_features = .{ .@"64bit", .avx, null, null },
	49890	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49891	.dst_constraints = .{.{ .unsigned_int = .xword }},
	49892	.patterns = &.{
	49893	.{ .src = .{ .to_mem, .none, .none } },
	49894	},
	49895	.call_frame = .{ .size = 16, .alignment = .@"16" },
	49896	.extra_temps = .{
	49897	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	49898	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	49899	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } },
	49900	.unused,
	49901	.unused,
	49902	.unused,
	49903	.unused,
	49904	.unused,
	49905	.unused,
	49906	},
	49907	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49908	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49909	.each = .{ .once = &.{
	49910	.{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ },
	49911	.{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
	49912	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	49913	} },
	49914	}, .{
	49915	.required_features = .{ .@"64bit", .sse2, null, null },
	49916	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49917	.dst_constraints = .{.{ .unsigned_int = .xword }},
	49918	.patterns = &.{
	49919	.{ .src = .{ .to_mem, .none, .none } },
	49920	},
	49921	.call_frame = .{ .size = 16, .alignment = .@"16" },
	49922	.extra_temps = .{
	49923	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	49924	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	49925	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } },
	49926	.unused,
	49927	.unused,
	49928	.unused,
	49929	.unused,
	49930	.unused,
	49931	.unused,
	49932	},
	49933	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49934	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49935	.each = .{ .once = &.{
	49936	.{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
	49937	.{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ },
	49938	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	49939	} },
	49940	}, .{
	49941	.required_features = .{ .@"64bit", .sse, null, null },
	49942	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49943	.dst_constraints = .{.{ .unsigned_int = .xword }},
	49944	.patterns = &.{
	49945	.{ .src = .{ .to_mem, .none, .none } },
	49946	},
	49947	.call_frame = .{ .size = 16, .alignment = .@"16" },
	49948	.extra_temps = .{
	49949	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	49950	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	49951	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } },
	49952	.unused,
	49953	.unused,
	49954	.unused,
	49955	.unused,
	49956	.unused,
	49957	.unused,
	49958	},
	49959	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	49960	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49961	.each = .{ .once = &.{
	49962	.{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ },
	49963	.{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ },
	49964	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	49965	} },
	49966	}, .{
	49967	.required_features = .{ .@"64bit", .avx, null, null },
	49968	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49969	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }},
	49970	.patterns = &.{
	49971	.{ .src = .{ .to_mem, .none, .none } },
	49972	},
	49973	.call_frame = .{ .size = 16, .alignment = .@"16" },
	49974	.extra_temps = .{
	49975	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	49976	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	49977	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	49978	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	49979	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } },
	49980	.unused,
	49981	.unused,
	49982	.unused,
	49983	.unused,
	49984	},
	49985	.dst_temps = .{.mem},
	49986	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	49987	.each = .{ .once = &.{
	49988	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	49989	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	49990	.{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ },
	49991	.{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
	49992	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	49993	} },
	49994	}, .{
	49995	.required_features = .{ .@"64bit", .sse2, null, null },
	49996	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	49997	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }},
	49998	.patterns = &.{
	49999	.{ .src = .{ .to_mem, .none, .none } },
	50000	},
	50001	.call_frame = .{ .size = 16, .alignment = .@"16" },
	50002	.extra_temps = .{
	50003	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50004	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50005	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	50006	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	50007	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } },
	50008	.unused,
	50009	.unused,
	50010	.unused,
	50011	.unused,
	50012	},
	50013	.dst_temps = .{.mem},
	50014	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50015	.each = .{ .once = &.{
	50016	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	50017	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	50018	.{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ },
	50019	.{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
	50020	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	50021	} },
	50022	}, .{
	50023	.required_features = .{ .@"64bit", .sse, null, null },
	50024	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	50025	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }},
	50026	.patterns = &.{
	50027	.{ .src = .{ .to_mem, .none, .none } },
	50028	},
	50029	.call_frame = .{ .size = 16, .alignment = .@"16" },
	50030	.extra_temps = .{
	50031	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50032	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50033	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	50034	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	50035	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } },
	50036	.unused,
	50037	.unused,
	50038	.unused,
	50039	.unused,
	50040	},
	50041	.dst_temps = .{.mem},
	50042	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50043	.each = .{ .once = &.{
	50044	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	50045	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	50046	.{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ },
	50047	.{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
	50048	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	50049	} },
	50050	}, .{
	50051	.required_features = .{ .@"64bit", .avx, null, null },
	50052	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	50053	.dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }},
	50054	.patterns = &.{
	50055	.{ .src = .{ .to_mem, .none, .none } },
	50056	},
	50057	.call_frame = .{ .size = 16, .alignment = .@"16" },
	50058	.extra_temps = .{
	50059	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50060	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50061	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	50062	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	50063	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } },
	50064	.unused,
	50065	.unused,
	50066	.unused,
	50067	.unused,
	50068	},
	50069	.dst_temps = .{.mem},
	50070	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50071	.each = .{ .once = &.{
	50072	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	50073	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	50074	.{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ },
	50075	.{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
	50076	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	50077	} },
	50078	}, .{
	50079	.required_features = .{ .@"64bit", .sse2, null, null },
	50080	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	50081	.dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }},
	50082	.patterns = &.{
	50083	.{ .src = .{ .to_mem, .none, .none } },
	50084	},
	50085	.call_frame = .{ .size = 16, .alignment = .@"16" },
	50086	.extra_temps = .{
	50087	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50088	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50089	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	50090	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	50091	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } },
	50092	.unused,
	50093	.unused,
	50094	.unused,
	50095	.unused,
	50096	},
	50097	.dst_temps = .{.mem},
	50098	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50099	.each = .{ .once = &.{
	50100	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	50101	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	50102	.{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ },
	50103	.{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ },
	50104	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	50105	} },
	50106	}, .{
	50107	.required_features = .{ .@"64bit", .sse, null, null },
	50108	.src_constraints = .{ .{ .float = .tbyte }, .any, .any },
	50109	.dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }},
	50110	.patterns = &.{
	50111	.{ .src = .{ .to_mem, .none, .none } },
	50112	},
	50113	.call_frame = .{ .size = 16, .alignment = .@"16" },
	50114	.extra_temps = .{
	50115	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50116	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50117	.{ .type = .f80, .kind = .{ .reg = .xmm0 } },
	50118	.{ .type = .f80, .kind = .{ .frame = .call_frame } },
	50119	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } },
	50120	.unused,
	50121	.unused,
	50122	.unused,
	50123	.unused,
	50124	},
	50125	.dst_temps = .{.mem},
	50126	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50127	.each = .{ .once = &.{
	50128	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	50129	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	50130	.{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ },
	50131	.{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ },
	50132	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	50133	} },
	50134	}, .{
	50135	.required_features = .{ .sse, null, null, null },
	50136	.src_constraints = .{ .{ .float = .xword }, .any, .any },
	50137	.dst_constraints = .{.{ .signed_int = .dword }},
	50138	.patterns = &.{
	50139	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	50140	},
	50141	.call_frame = .{ .alignment = .@"16" },
	50142	.extra_temps = .{
	50143	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } },
	50144	.unused,
	50145	.unused,
	50146	.unused,
	50147	.unused,
	50148	.unused,
	50149	.unused,
	50150	.unused,
	50151	.unused,
	50152	},
	50153	.dst_temps = .{.{ .reg = .eax }},
	50154	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50155	.each = .{ .once = &.{
	50156	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50157	} },
	50158	}, .{
	50159	.required_features = .{ .sse, null, null, null },
	50160	.src_constraints = .{ .{ .float = .xword }, .any, .any },
	50161	.dst_constraints = .{.{ .unsigned_int = .dword }},
	50162	.patterns = &.{
	50163	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	50164	},
	50165	.call_frame = .{ .alignment = .@"16" },
	50166	.extra_temps = .{
	50167	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfsi" } } },
	50168	.unused,
	50169	.unused,
	50170	.unused,
	50171	.unused,
	50172	.unused,
	50173	.unused,
	50174	.unused,
	50175	.unused,
	50176	},
	50177	.dst_temps = .{.{ .reg = .eax }},
	50178	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50179	.each = .{ .once = &.{
	50180	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50181	} },
	50182	}, .{
	50183	.required_features = .{ .@"64bit", .sse, null, null },
	50184	.src_constraints = .{ .{ .float = .xword }, .any, .any },
	50185	.dst_constraints = .{.{ .signed_int = .qword }},
	50186	.patterns = &.{
	50187	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	50188	},
	50189	.call_frame = .{ .alignment = .@"16" },
	50190	.extra_temps = .{
	50191	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfdi" } } },
	50192	.unused,
	50193	.unused,
	50194	.unused,
	50195	.unused,
	50196	.unused,
	50197	.unused,
	50198	.unused,
	50199	.unused,
	50200	},
	50201	.dst_temps = .{.{ .reg = .rax }},
	50202	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50203	.each = .{ .once = &.{
	50204	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50205	} },
	50206	}, .{
	50207	.required_features = .{ .@"64bit", .sse, null, null },
	50208	.src_constraints = .{ .{ .float = .xword }, .any, .any },
	50209	.dst_constraints = .{.{ .unsigned_int = .qword }},
	50210	.patterns = &.{
	50211	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	50212	},
	50213	.call_frame = .{ .alignment = .@"16" },
	50214	.extra_temps = .{
	50215	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfdi" } } },
	50216	.unused,
	50217	.unused,
	50218	.unused,
	50219	.unused,
	50220	.unused,
	50221	.unused,
	50222	.unused,
	50223	.unused,
	50224	},
	50225	.dst_temps = .{.{ .reg = .rax }},
	50226	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50227	.each = .{ .once = &.{
	50228	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50229	} },
	50230	}, .{
	50231	.required_features = .{ .@"64bit", .sse, null, null },
	50232	.src_constraints = .{ .{ .float = .xword }, .any, .any },
	50233	.dst_constraints = .{.{ .signed_int = .xword }},
	50234	.patterns = &.{
	50235	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	50236	},
	50237	.call_frame = .{ .alignment = .@"16" },
	50238	.extra_temps = .{
	50239	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfti" } } },
	50240	.unused,
	50241	.unused,
	50242	.unused,
	50243	.unused,
	50244	.unused,
	50245	.unused,
	50246	.unused,
	50247	.unused,
	50248	},
	50249	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	50250	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50251	.each = .{ .once = &.{
	50252	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50253	} },
	50254	}, .{
	50255	.required_features = .{ .@"64bit", .sse, null, null },
	50256	.src_constraints = .{ .{ .float = .xword }, .any, .any },
	50257	.dst_constraints = .{.{ .unsigned_int = .xword }},
	50258	.patterns = &.{
	50259	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	50260	},
	50261	.call_frame = .{ .alignment = .@"16" },
	50262	.extra_temps = .{
	50263	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfti" } } },
	50264	.unused,
	50265	.unused,
	50266	.unused,
	50267	.unused,
	50268	.unused,
	50269	.unused,
	50270	.unused,
	50271	.unused,
	50272	},
	50273	.dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }},
	50274	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50275	.each = .{ .once = &.{
	50276	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50277	} },
	50278	}, .{
	50279	.required_features = .{ .@"64bit", .sse, null, null },
	50280	.src_constraints = .{ .{ .float = .xword }, .any, .any },
	50281	.dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }},
	50282	.patterns = &.{
	50283	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	50284	},
	50285	.call_frame = .{ .alignment = .@"16" },
	50286	.extra_temps = .{
	50287	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50288	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50289	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfei" } } },
	50290	.unused,
	50291	.unused,
	50292	.unused,
	50293	.unused,
	50294	.unused,
	50295	.unused,
	50296	},
	50297	.dst_temps = .{.mem},
	50298	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50299	.each = .{ .once = &.{
	50300	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	50301	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	50302	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	50303	} },
	50304	}, .{
	50305	.required_features = .{ .@"64bit", .sse, null, null },
	50306	.src_constraints = .{ .{ .float = .xword }, .any, .any },
	50307	.dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }},
	50308	.patterns = &.{
	50309	.{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } },
	50310	},
	50311	.call_frame = .{ .alignment = .@"16" },
	50312	.extra_temps = .{
	50313	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50314	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50315	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfei" } } },
	50316	.unused,
	50317	.unused,
	50318	.unused,
	50319	.unused,
	50320	.unused,
	50321	.unused,
	50322	},
	50323	.dst_temps = .{.mem},
	50324	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50325	.each = .{ .once = &.{
	50326	.{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
	50327	.{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ },
	50328	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	50329	} },
	50330	} }) catch \|err\| switch (err) {
	50331	error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
	50332	@tagName(air_tag),
	50333	ty_op.ty.toType().fmt(pt),
	50334	cg.typeOf(ty_op.operand).fmt(pt),
	50335	ops[0].tracking(cg),
	50336	}),
	50337	else => \|e\| return e,
	50338	};
	50339	try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
	50340	},
	50341	.float_from_int => \|air_tag\| if (use_old) try cg.airFloatFromInt(inst) else fallback: {
	50342	const ty_op = air_datas[@intFromEnum(inst)].ty_op;
	50343	if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airFloatFromInt(inst);
	50344	var ops = try cg.tempsFromOperands(inst, .{ty_op.operand});
	50345	var res: [1]Temp = undefined;
	50346	cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{
	50347	.required_features = .{ .f16c, null, null, null },
	50348	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	50349	.dst_constraints = .{.{ .float = .word }},
	50350	.patterns = &.{
	50351	.{ .src = .{ .mem, .none, .none } },
	50352	.{ .src = .{ .to_gpr, .none, .none } },
	50353	},
	50354	.extra_temps = .{
	50355	.{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50356	.unused,
	50357	.unused,
	50358	.unused,
	50359	.unused,
	50360	.unused,
	50361	.unused,
	50362	.unused,
	50363	.unused,
	50364	},
	50365	.dst_temps = .{.{ .rc = .sse }},
	50366	.each = .{ .once = &.{
	50367	.{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
	50368	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50369	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	50370	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	50371	} },
	50372	}, .{
	50373	.required_features = .{ .f16c, null, null, null },
	50374	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	50375	.dst_constraints = .{.{ .float = .word }},
	50376	.patterns = &.{
	50377	.{ .src = .{ .mem, .none, .none } },
	50378	.{ .src = .{ .to_gpr, .none, .none } },
	50379	},
	50380	.extra_temps = .{
	50381	.{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50382	.unused,
	50383	.unused,
	50384	.unused,
	50385	.unused,
	50386	.unused,
	50387	.unused,
	50388	.unused,
	50389	.unused,
	50390	},
	50391	.dst_temps = .{.{ .rc = .sse }},
	50392	.each = .{ .once = &.{
	50393	.{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
	50394	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50395	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	50396	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	50397	} },
	50398	}, .{
	50399	.required_features = .{ .f16c, null, null, null },
	50400	.src_constraints = .{ .{ .signed_int = .word }, .any, .any },
	50401	.dst_constraints = .{.{ .float = .word }},
	50402	.patterns = &.{
	50403	.{ .src = .{ .mem, .none, .none } },
	50404	.{ .src = .{ .to_gpr, .none, .none } },
	50405	},
	50406	.extra_temps = .{
	50407	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50408	.unused,
	50409	.unused,
	50410	.unused,
	50411	.unused,
	50412	.unused,
	50413	.unused,
	50414	.unused,
	50415	.unused,
	50416	},
	50417	.dst_temps = .{.{ .rc = .sse }},
	50418	.each = .{ .once = &.{
	50419	.{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
	50420	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50421	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	50422	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	50423	} },
	50424	}, .{
	50425	.required_features = .{ .f16c, null, null, null },
	50426	.src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
	50427	.dst_constraints = .{.{ .float = .word }},
	50428	.patterns = &.{
	50429	.{ .src = .{ .mem, .none, .none } },
	50430	.{ .src = .{ .to_gpr, .none, .none } },
	50431	},
	50432	.extra_temps = .{
	50433	.{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50434	.unused,
	50435	.unused,
	50436	.unused,
	50437	.unused,
	50438	.unused,
	50439	.unused,
	50440	.unused,
	50441	.unused,
	50442	},
	50443	.dst_temps = .{.{ .rc = .sse }},
	50444	.each = .{ .once = &.{
	50445	.{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
	50446	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50447	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	50448	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	50449	} },
	50450	}, .{
	50451	.required_features = .{ .f16c, null, null, null },
	50452	.src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
	50453	.dst_constraints = .{.{ .float = .word }},
	50454	.patterns = &.{
	50455	.{ .src = .{ .mem, .none, .none } },
	50456	.{ .src = .{ .to_gpr, .none, .none } },
	50457	},
	50458	.dst_temps = .{.{ .rc = .sse }},
	50459	.each = .{ .once = &.{
	50460	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50461	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ },
	50462	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	50463	} },
	50464	}, .{
	50465	.required_features = .{ .@"64bit", .f16c, null, null },
	50466	.src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
	50467	.dst_constraints = .{.{ .float = .word }},
	50468	.patterns = &.{
	50469	.{ .src = .{ .mem, .none, .none } },
	50470	.{ .src = .{ .to_gpr, .none, .none } },
	50471	},
	50472	.extra_temps = .{
	50473	.{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50474	.unused,
	50475	.unused,
	50476	.unused,
	50477	.unused,
	50478	.unused,
	50479	.unused,
	50480	.unused,
	50481	.unused,
	50482	},
	50483	.dst_temps = .{.{ .rc = .sse }},
	50484	.each = .{ .once = &.{
	50485	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	50486	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50487	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ },
	50488	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	50489	} },
	50490	}, .{
	50491	.required_features = .{ .@"64bit", .f16c, null, null },
	50492	.src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
	50493	.dst_constraints = .{.{ .float = .word }},
	50494	.patterns = &.{
	50495	.{ .src = .{ .mem, .none, .none } },
	50496	.{ .src = .{ .to_gpr, .none, .none } },
	50497	},
	50498	.dst_temps = .{.{ .rc = .sse }},
	50499	.each = .{ .once = &.{
	50500	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50501	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
	50502	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	50503	} },
	50504	}, .{
	50505	.required_features = .{ .@"64bit", .f16c, null, null },
	50506	.src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
	50507	.dst_constraints = .{.{ .float = .word }},
	50508	.patterns = &.{
	50509	.{ .src = .{ .to_mut_gpr, .none, .none } },
	50510	},
	50511	.extra_temps = .{
	50512	.{ .type = .u1, .kind = .{ .rc = .general_purpose } },
	50513	.unused,
	50514	.unused,
	50515	.unused,
	50516	.unused,
	50517	.unused,
	50518	.unused,
	50519	.unused,
	50520	.unused,
	50521	},
	50522	.dst_temps = .{.{ .rc = .sse }},
	50523	.clobbers = .{ .eflags = true },
	50524	.each = .{ .once = &.{
	50525	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50526	.{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
	50527	.{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
	50528	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	50529	.{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
	50530	.{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ },
	50531	.{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ },
	50532	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
	50533	.{ ._, .v_ss, .add, .dst0x, .dst0x, .dst0d, ._ },
	50534	.{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
	50535	.{ .@"1:", .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
	50536	.{ .@"0:", .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	50537	} },
	50538	}, .{
	50539	.required_features = .{ .sse, null, null, null },
	50540	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	50541	.dst_constraints = .{.{ .float = .word }},
	50542	.patterns = &.{
	50543	.{ .src = .{ .{ .to_reg = .dil }, .none, .none } },
	50544	},
	50545	.call_frame = .{ .alignment = .@"16" },
	50546	.extra_temps = .{
	50547	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } },
	50548	.unused,
	50549	.unused,
	50550	.unused,
	50551	.unused,
	50552	.unused,
	50553	.unused,
	50554	.unused,
	50555	.unused,
	50556	},
	50557	.dst_temps = .{.{ .reg = .xmm0 }},
	50558	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50559	.each = .{ .once = &.{
	50560	.{ ._, ._, .movsx, .src0d, .src0b, ._, ._ },
	50561	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50562	} },
	50563	}, .{
	50564	.required_features = .{ .sse, null, null, null },
	50565	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	50566	.dst_constraints = .{.{ .float = .word }},
	50567	.patterns = &.{
	50568	.{ .src = .{ .{ .to_reg = .dil }, .none, .none } },
	50569	},
	50570	.call_frame = .{ .alignment = .@"16" },
	50571	.extra_temps = .{
	50572	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } },
	50573	.unused,
	50574	.unused,
	50575	.unused,
	50576	.unused,
	50577	.unused,
	50578	.unused,
	50579	.unused,
	50580	.unused,
	50581	},
	50582	.dst_temps = .{.{ .reg = .xmm0 }},
	50583	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50584	.each = .{ .once = &.{
	50585	.{ ._, ._, .movzx, .src0d, .src0b, ._, ._ },
	50586	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50587	} },
	50588	}, .{
	50589	.required_features = .{ .sse, null, null, null },
	50590	.src_constraints = .{ .{ .signed_int = .word }, .any, .any },
	50591	.dst_constraints = .{.{ .float = .word }},
	50592	.patterns = &.{
	50593	.{ .src = .{ .{ .to_reg = .di }, .none, .none } },
	50594	},
	50595	.call_frame = .{ .alignment = .@"16" },
	50596	.extra_temps = .{
	50597	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } },
	50598	.unused,
	50599	.unused,
	50600	.unused,
	50601	.unused,
	50602	.unused,
	50603	.unused,
	50604	.unused,
	50605	.unused,
	50606	},
	50607	.dst_temps = .{.{ .reg = .xmm0 }},
	50608	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50609	.each = .{ .once = &.{
	50610	.{ ._, ._, .movsx, .src0d, .src0w, ._, ._ },
	50611	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50612	} },
	50613	}, .{
	50614	.required_features = .{ .sse, null, null, null },
	50615	.src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
	50616	.dst_constraints = .{.{ .float = .word }},
	50617	.patterns = &.{
	50618	.{ .src = .{ .{ .to_reg = .di }, .none, .none } },
	50619	},
	50620	.call_frame = .{ .alignment = .@"16" },
	50621	.extra_temps = .{
	50622	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } },
	50623	.unused,
	50624	.unused,
	50625	.unused,
	50626	.unused,
	50627	.unused,
	50628	.unused,
	50629	.unused,
	50630	.unused,
	50631	},
	50632	.dst_temps = .{.{ .reg = .xmm0 }},
	50633	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50634	.each = .{ .once = &.{
	50635	.{ ._, ._, .movzx, .src0d, .src0w, ._, ._ },
	50636	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50637	} },
	50638	}, .{
	50639	.required_features = .{ .sse, null, null, null },
	50640	.src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
	50641	.dst_constraints = .{.{ .float = .word }},
	50642	.patterns = &.{
	50643	.{ .src = .{ .{ .to_reg = .edi }, .none, .none } },
	50644	},
	50645	.call_frame = .{ .alignment = .@"16" },
	50646	.extra_temps = .{
	50647	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } },
	50648	.unused,
	50649	.unused,
	50650	.unused,
	50651	.unused,
	50652	.unused,
	50653	.unused,
	50654	.unused,
	50655	.unused,
	50656	},
	50657	.dst_temps = .{.{ .reg = .xmm0 }},
	50658	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50659	.each = .{ .once = &.{
	50660	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50661	} },
	50662	}, .{
	50663	.required_features = .{ .sse, null, null, null },
	50664	.src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
	50665	.dst_constraints = .{.{ .float = .word }},
	50666	.patterns = &.{
	50667	.{ .src = .{ .{ .to_reg = .edi }, .none, .none } },
	50668	},
	50669	.call_frame = .{ .alignment = .@"16" },
	50670	.extra_temps = .{
	50671	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } },
	50672	.unused,
	50673	.unused,
	50674	.unused,
	50675	.unused,
	50676	.unused,
	50677	.unused,
	50678	.unused,
	50679	.unused,
	50680	},
	50681	.dst_temps = .{.{ .reg = .xmm0 }},
	50682	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50683	.each = .{ .once = &.{
	50684	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50685	} },
	50686	}, .{
	50687	.required_features = .{ .@"64bit", .sse, null, null },
	50688	.src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
	50689	.dst_constraints = .{.{ .float = .word }},
	50690	.patterns = &.{
	50691	.{ .src = .{ .{ .to_reg = .rdi }, .none, .none } },
	50692	},
	50693	.call_frame = .{ .alignment = .@"16" },
	50694	.extra_temps = .{
	50695	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdihf" } } },
	50696	.unused,
	50697	.unused,
	50698	.unused,
	50699	.unused,
	50700	.unused,
	50701	.unused,
	50702	.unused,
	50703	.unused,
	50704	},
	50705	.dst_temps = .{.{ .reg = .xmm0 }},
	50706	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50707	.each = .{ .once = &.{
	50708	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50709	} },
	50710	}, .{
	50711	.required_features = .{ .@"64bit", .sse, null, null },
	50712	.src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
	50713	.dst_constraints = .{.{ .float = .word }},
	50714	.patterns = &.{
	50715	.{ .src = .{ .{ .to_reg = .rdi }, .none, .none } },
	50716	},
	50717	.call_frame = .{ .alignment = .@"16" },
	50718	.extra_temps = .{
	50719	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundihf" } } },
	50720	.unused,
	50721	.unused,
	50722	.unused,
	50723	.unused,
	50724	.unused,
	50725	.unused,
	50726	.unused,
	50727	.unused,
	50728	},
	50729	.dst_temps = .{.{ .reg = .xmm0 }},
	50730	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50731	.each = .{ .once = &.{
	50732	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50733	} },
	50734	}, .{
	50735	.required_features = .{ .@"64bit", .sse, null, null },
	50736	.src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
	50737	.dst_constraints = .{.{ .float = .word }},
	50738	.patterns = &.{
	50739	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	50740	},
	50741	.call_frame = .{ .alignment = .@"16" },
	50742	.extra_temps = .{
	50743	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattihf" } } },
	50744	.unused,
	50745	.unused,
	50746	.unused,
	50747	.unused,
	50748	.unused,
	50749	.unused,
	50750	.unused,
	50751	.unused,
	50752	},
	50753	.dst_temps = .{.{ .reg = .xmm0 }},
	50754	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50755	.each = .{ .once = &.{
	50756	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50757	} },
	50758	}, .{
	50759	.required_features = .{ .@"64bit", .sse, null, null },
	50760	.src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
	50761	.dst_constraints = .{.{ .float = .word }},
	50762	.patterns = &.{
	50763	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	50764	},
	50765	.call_frame = .{ .alignment = .@"16" },
	50766	.extra_temps = .{
	50767	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntihf" } } },
	50768	.unused,
	50769	.unused,
	50770	.unused,
	50771	.unused,
	50772	.unused,
	50773	.unused,
	50774	.unused,
	50775	.unused,
	50776	},
	50777	.dst_temps = .{.{ .reg = .xmm0 }},
	50778	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50779	.each = .{ .once = &.{
	50780	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	50781	} },
	50782	}, .{
	50783	.required_features = .{ .@"64bit", .sse, null, null },
	50784	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	50785	.dst_constraints = .{.{ .float = .word }},
	50786	.patterns = &.{
	50787	.{ .src = .{ .to_mem, .none, .none } },
	50788	},
	50789	.call_frame = .{ .alignment = .@"16" },
	50790	.extra_temps = .{
	50791	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50792	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50793	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateihf" } } },
	50794	.unused,
	50795	.unused,
	50796	.unused,
	50797	.unused,
	50798	.unused,
	50799	.unused,
	50800	},
	50801	.dst_temps = .{.{ .reg = .xmm0 }},
	50802	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50803	.each = .{ .once = &.{
	50804	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	50805	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	50806	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	50807	} },
	50808	}, .{
	50809	.required_features = .{ .@"64bit", .sse, null, null },
	50810	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	50811	.dst_constraints = .{.{ .float = .word }},
	50812	.patterns = &.{
	50813	.{ .src = .{ .to_mem, .none, .none } },
	50814	},
	50815	.call_frame = .{ .alignment = .@"16" },
	50816	.extra_temps = .{
	50817	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	50818	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	50819	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneihf" } } },
	50820	.unused,
	50821	.unused,
	50822	.unused,
	50823	.unused,
	50824	.unused,
	50825	.unused,
	50826	},
	50827	.dst_temps = .{.{ .reg = .xmm0 }},
	50828	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	50829	.each = .{ .once = &.{
	50830	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	50831	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	50832	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	50833	} },
	50834	}, .{
	50835	.required_features = .{ .avx, null, null, null },
	50836	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	50837	.dst_constraints = .{.{ .float = .dword }},
	50838	.patterns = &.{
	50839	.{ .src = .{ .mem, .none, .none } },
	50840	.{ .src = .{ .to_gpr, .none, .none } },
	50841	},
	50842	.extra_temps = .{
	50843	.{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50844	.unused,
	50845	.unused,
	50846	.unused,
	50847	.unused,
	50848	.unused,
	50849	.unused,
	50850	.unused,
	50851	.unused,
	50852	},
	50853	.dst_temps = .{.{ .rc = .sse }},
	50854	.each = .{ .once = &.{
	50855	.{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
	50856	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50857	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	50858	} },
	50859	}, .{
	50860	.required_features = .{ .sse, null, null, null },
	50861	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	50862	.dst_constraints = .{.{ .float = .dword }},
	50863	.patterns = &.{
	50864	.{ .src = .{ .mem, .none, .none } },
	50865	.{ .src = .{ .to_gpr, .none, .none } },
	50866	},
	50867	.extra_temps = .{
	50868	.{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50869	.unused,
	50870	.unused,
	50871	.unused,
	50872	.unused,
	50873	.unused,
	50874	.unused,
	50875	.unused,
	50876	.unused,
	50877	},
	50878	.dst_temps = .{.{ .rc = .sse }},
	50879	.each = .{ .once = &.{
	50880	.{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
	50881	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
	50882	.{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
	50883	} },
	50884	}, .{
	50885	.required_features = .{ .avx, null, null, null },
	50886	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	50887	.dst_constraints = .{.{ .float = .dword }},
	50888	.patterns = &.{
	50889	.{ .src = .{ .mem, .none, .none } },
	50890	.{ .src = .{ .to_gpr, .none, .none } },
	50891	},
	50892	.extra_temps = .{
	50893	.{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50894	.unused,
	50895	.unused,
	50896	.unused,
	50897	.unused,
	50898	.unused,
	50899	.unused,
	50900	.unused,
	50901	.unused,
	50902	},
	50903	.dst_temps = .{.{ .rc = .sse }},
	50904	.each = .{ .once = &.{
	50905	.{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
	50906	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50907	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	50908	} },
	50909	}, .{
	50910	.required_features = .{ .sse, null, null, null },
	50911	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	50912	.dst_constraints = .{.{ .float = .dword }},
	50913	.patterns = &.{
	50914	.{ .src = .{ .mem, .none, .none } },
	50915	.{ .src = .{ .to_gpr, .none, .none } },
	50916	},
	50917	.extra_temps = .{
	50918	.{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50919	.unused,
	50920	.unused,
	50921	.unused,
	50922	.unused,
	50923	.unused,
	50924	.unused,
	50925	.unused,
	50926	.unused,
	50927	},
	50928	.dst_temps = .{.{ .rc = .sse }},
	50929	.each = .{ .once = &.{
	50930	.{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
	50931	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
	50932	.{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
	50933	} },
	50934	}, .{
	50935	.required_features = .{ .avx, null, null, null },
	50936	.src_constraints = .{ .{ .signed_int = .word }, .any, .any },
	50937	.dst_constraints = .{.{ .float = .dword }},
	50938	.patterns = &.{
	50939	.{ .src = .{ .mem, .none, .none } },
	50940	.{ .src = .{ .to_gpr, .none, .none } },
	50941	},
	50942	.extra_temps = .{
	50943	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50944	.unused,
	50945	.unused,
	50946	.unused,
	50947	.unused,
	50948	.unused,
	50949	.unused,
	50950	.unused,
	50951	.unused,
	50952	},
	50953	.dst_temps = .{.{ .rc = .sse }},
	50954	.each = .{ .once = &.{
	50955	.{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
	50956	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	50957	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	50958	} },
	50959	}, .{
	50960	.required_features = .{ .sse, null, null, null },
	50961	.src_constraints = .{ .{ .signed_int = .word }, .any, .any },
	50962	.dst_constraints = .{.{ .float = .dword }},
	50963	.patterns = &.{
	50964	.{ .src = .{ .mem, .none, .none } },
	50965	.{ .src = .{ .to_gpr, .none, .none } },
	50966	},
	50967	.extra_temps = .{
	50968	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50969	.unused,
	50970	.unused,
	50971	.unused,
	50972	.unused,
	50973	.unused,
	50974	.unused,
	50975	.unused,
	50976	.unused,
	50977	},
	50978	.dst_temps = .{.{ .rc = .sse }},
	50979	.each = .{ .once = &.{
	50980	.{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
	50981	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
	50982	.{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
	50983	} },
	50984	}, .{
	50985	.required_features = .{ .avx, null, null, null },
	50986	.src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
	50987	.dst_constraints = .{.{ .float = .dword }},
	50988	.patterns = &.{
	50989	.{ .src = .{ .mem, .none, .none } },
	50990	.{ .src = .{ .to_gpr, .none, .none } },
	50991	},
	50992	.extra_temps = .{
	50993	.{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	50994	.unused,
	50995	.unused,
	50996	.unused,
	50997	.unused,
	50998	.unused,
	50999	.unused,
	51000	.unused,
	51001	.unused,
	51002	},
	51003	.dst_temps = .{.{ .rc = .sse }},
	51004	.each = .{ .once = &.{
	51005	.{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
	51006	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51007	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	51008	} },
	51009	}, .{
	51010	.required_features = .{ .sse, null, null, null },
	51011	.src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
	51012	.dst_constraints = .{.{ .float = .dword }},
	51013	.patterns = &.{
	51014	.{ .src = .{ .mem, .none, .none } },
	51015	.{ .src = .{ .to_gpr, .none, .none } },
	51016	},
	51017	.extra_temps = .{
	51018	.{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51019	.unused,
	51020	.unused,
	51021	.unused,
	51022	.unused,
	51023	.unused,
	51024	.unused,
	51025	.unused,
	51026	.unused,
	51027	},
	51028	.dst_temps = .{.{ .rc = .sse }},
	51029	.each = .{ .once = &.{
	51030	.{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
	51031	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
	51032	.{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
	51033	} },
	51034	}, .{
	51035	.required_features = .{ .avx, null, null, null },
	51036	.src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
	51037	.dst_constraints = .{.{ .float = .dword }},
	51038	.patterns = &.{
	51039	.{ .src = .{ .mem, .none, .none } },
	51040	.{ .src = .{ .to_gpr, .none, .none } },
	51041	},
	51042	.dst_temps = .{.{ .rc = .sse }},
	51043	.each = .{ .once = &.{
	51044	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51045	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ },
	51046	} },
	51047	}, .{
	51048	.required_features = .{ .sse, null, null, null },
	51049	.src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
	51050	.dst_constraints = .{.{ .float = .dword }},
	51051	.patterns = &.{
	51052	.{ .src = .{ .mem, .none, .none } },
	51053	.{ .src = .{ .to_gpr, .none, .none } },
	51054	},
	51055	.dst_temps = .{.{ .rc = .sse }},
	51056	.each = .{ .once = &.{
	51057	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
	51058	.{ ._, ._ss, .cvtsi2, .dst0x, .src0d, ._, ._ },
	51059	} },
	51060	}, .{
	51061	.required_features = .{ .avx, null, null, null },
	51062	.src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
	51063	.dst_constraints = .{.{ .float = .dword }},
	51064	.patterns = &.{
	51065	.{ .src = .{ .mem, .none, .none } },
	51066	.{ .src = .{ .to_gpr, .none, .none } },
	51067	},
	51068	.extra_temps = .{
	51069	.{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51070	.unused,
	51071	.unused,
	51072	.unused,
	51073	.unused,
	51074	.unused,
	51075	.unused,
	51076	.unused,
	51077	.unused,
	51078	},
	51079	.dst_temps = .{.{ .rc = .sse }},
	51080	.each = .{ .once = &.{
	51081	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	51082	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51083	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ },
	51084	} },
	51085	}, .{
	51086	.required_features = .{ .sse, null, null, null },
	51087	.src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
	51088	.dst_constraints = .{.{ .float = .dword }},
	51089	.patterns = &.{
	51090	.{ .src = .{ .mem, .none, .none } },
	51091	.{ .src = .{ .to_gpr, .none, .none } },
	51092	},
	51093	.extra_temps = .{
	51094	.{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51095	.unused,
	51096	.unused,
	51097	.unused,
	51098	.unused,
	51099	.unused,
	51100	.unused,
	51101	.unused,
	51102	.unused,
	51103	},
	51104	.dst_temps = .{.{ .rc = .sse }},
	51105	.each = .{ .once = &.{
	51106	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	51107	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
	51108	.{ ._, ._ss, .cvtsi2, .dst0x, .tmp0q, ._, ._ },
	51109	} },
	51110	}, .{
	51111	.required_features = .{ .@"64bit", .avx, null, null },
	51112	.src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
	51113	.dst_constraints = .{.{ .float = .dword }},
	51114	.patterns = &.{
	51115	.{ .src = .{ .mem, .none, .none } },
	51116	.{ .src = .{ .to_gpr, .none, .none } },
	51117	},
	51118	.dst_temps = .{.{ .rc = .sse }},
	51119	.each = .{ .once = &.{
	51120	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51121	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
	51122	} },
	51123	}, .{
	51124	.required_features = .{ .@"64bit", .sse, null, null },
	51125	.src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
	51126	.dst_constraints = .{.{ .float = .dword }},
	51127	.patterns = &.{
	51128	.{ .src = .{ .mem, .none, .none } },
	51129	.{ .src = .{ .to_gpr, .none, .none } },
	51130	},
	51131	.dst_temps = .{.{ .rc = .sse }},
	51132	.each = .{ .once = &.{
	51133	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
	51134	.{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ },
	51135	} },
	51136	}, .{
	51137	.required_features = .{ .@"64bit", .avx, null, null },
	51138	.src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
	51139	.dst_constraints = .{.{ .float = .dword }},
	51140	.patterns = &.{
	51141	.{ .src = .{ .to_mut_gpr, .none, .none } },
	51142	},
	51143	.extra_temps = .{
	51144	.{ .type = .u1, .kind = .{ .rc = .general_purpose } },
	51145	.unused,
	51146	.unused,
	51147	.unused,
	51148	.unused,
	51149	.unused,
	51150	.unused,
	51151	.unused,
	51152	.unused,
	51153	},
	51154	.dst_temps = .{.{ .rc = .sse }},
	51155	.clobbers = .{ .eflags = true },
	51156	.each = .{ .once = &.{
	51157	.{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51158	.{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
	51159	.{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
	51160	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	51161	.{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
	51162	.{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ },
	51163	.{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ },
	51164	.{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
	51165	.{ ._, .v_ss, .add, .dst0x, .dst0x, .dst0d, ._ },
	51166	.{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
	51167	.{ .@"1:", .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
	51168	} },
	51169	}, .{
	51170	.required_features = .{ .@"64bit", .sse, null, null },
	51171	.src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
	51172	.dst_constraints = .{.{ .float = .dword }},
	51173	.patterns = &.{
	51174	.{ .src = .{ .to_mut_gpr, .none, .none } },
	51175	},
	51176	.extra_temps = .{
	51177	.{ .type = .u1, .kind = .{ .rc = .general_purpose } },
	51178	.unused,
	51179	.unused,
	51180	.unused,
	51181	.unused,
	51182	.unused,
	51183	.unused,
	51184	.unused,
	51185	.unused,
	51186	},
	51187	.dst_temps = .{.{ .rc = .sse }},
	51188	.clobbers = .{ .eflags = true },
	51189	.each = .{ .once = &.{
	51190	.{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ },
	51191	.{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
	51192	.{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
	51193	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	51194	.{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
	51195	.{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ },
	51196	.{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ },
	51197	.{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ },
	51198	.{ ._, ._ss, .add, .dst0x, .dst0d, ._, ._ },
	51199	.{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
	51200	.{ .@"1:", ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ },
	51201	} },
	51202	}, .{
	51203	.required_features = .{ .@"64bit", .sse, null, null },
	51204	.src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
	51205	.dst_constraints = .{.{ .float = .dword }},
	51206	.patterns = &.{
	51207	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	51208	},
	51209	.call_frame = .{ .alignment = .@"16" },
	51210	.extra_temps = .{
	51211	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattisf" } } },
	51212	.unused,
	51213	.unused,
	51214	.unused,
	51215	.unused,
	51216	.unused,
	51217	.unused,
	51218	.unused,
	51219	.unused,
	51220	},
	51221	.dst_temps = .{.{ .reg = .xmm0 }},
	51222	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	51223	.each = .{ .once = &.{
	51224	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	51225	} },
	51226	}, .{
	51227	.required_features = .{ .@"64bit", .sse, null, null },
	51228	.src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
	51229	.dst_constraints = .{.{ .float = .dword }},
	51230	.patterns = &.{
	51231	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	51232	},
	51233	.call_frame = .{ .alignment = .@"16" },
	51234	.extra_temps = .{
	51235	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntisf" } } },
	51236	.unused,
	51237	.unused,
	51238	.unused,
	51239	.unused,
	51240	.unused,
	51241	.unused,
	51242	.unused,
	51243	.unused,
	51244	},
	51245	.dst_temps = .{.{ .reg = .xmm0 }},
	51246	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	51247	.each = .{ .once = &.{
	51248	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	51249	} },
	51250	}, .{
	51251	.required_features = .{ .@"64bit", .sse, null, null },
	51252	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	51253	.dst_constraints = .{.{ .float = .dword }},
	51254	.patterns = &.{
	51255	.{ .src = .{ .to_mem, .none, .none } },
	51256	},
	51257	.call_frame = .{ .alignment = .@"16" },
	51258	.extra_temps = .{
	51259	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	51260	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	51261	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateisf" } } },
	51262	.unused,
	51263	.unused,
	51264	.unused,
	51265	.unused,
	51266	.unused,
	51267	.unused,
	51268	},
	51269	.dst_temps = .{.{ .reg = .xmm0 }},
	51270	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	51271	.each = .{ .once = &.{
	51272	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	51273	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	51274	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	51275	} },
	51276	}, .{
	51277	.required_features = .{ .@"64bit", .sse, null, null },
	51278	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	51279	.dst_constraints = .{.{ .float = .dword }},
	51280	.patterns = &.{
	51281	.{ .src = .{ .to_mem, .none, .none } },
	51282	},
	51283	.call_frame = .{ .alignment = .@"16" },
	51284	.extra_temps = .{
	51285	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	51286	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	51287	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneisf" } } },
	51288	.unused,
	51289	.unused,
	51290	.unused,
	51291	.unused,
	51292	.unused,
	51293	.unused,
	51294	},
	51295	.dst_temps = .{.{ .reg = .xmm0 }},
	51296	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	51297	.each = .{ .once = &.{
	51298	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	51299	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	51300	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	51301	} },
	51302	}, .{
	51303	.required_features = .{ .avx, null, null, null },
	51304	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	51305	.dst_constraints = .{.{ .float = .qword }},
	51306	.patterns = &.{
	51307	.{ .src = .{ .mem, .none, .none } },
	51308	.{ .src = .{ .to_gpr, .none, .none } },
	51309	},
	51310	.extra_temps = .{
	51311	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51312	.unused,
	51313	.unused,
	51314	.unused,
	51315	.unused,
	51316	.unused,
	51317	.unused,
	51318	.unused,
	51319	.unused,
	51320	},
	51321	.dst_temps = .{.{ .rc = .sse }},
	51322	.each = .{ .once = &.{
	51323	.{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
	51324	.{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51325	.{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	51326	} },
	51327	}, .{
	51328	.required_features = .{ .sse2, null, null, null },
	51329	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	51330	.dst_constraints = .{.{ .float = .qword }},
	51331	.patterns = &.{
	51332	.{ .src = .{ .mem, .none, .none } },
	51333	.{ .src = .{ .to_gpr, .none, .none } },
	51334	},
	51335	.extra_temps = .{
	51336	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51337	.unused,
	51338	.unused,
	51339	.unused,
	51340	.unused,
	51341	.unused,
	51342	.unused,
	51343	.unused,
	51344	.unused,
	51345	},
	51346	.dst_temps = .{.{ .rc = .sse }},
	51347	.each = .{ .once = &.{
	51348	.{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
	51349	.{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
	51350	.{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
	51351	} },
	51352	}, .{
	51353	.required_features = .{ .avx, null, null, null },
	51354	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	51355	.dst_constraints = .{.{ .float = .qword }},
	51356	.patterns = &.{
	51357	.{ .src = .{ .mem, .none, .none } },
	51358	.{ .src = .{ .to_gpr, .none, .none } },
	51359	},
	51360	.extra_temps = .{
	51361	.{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51362	.unused,
	51363	.unused,
	51364	.unused,
	51365	.unused,
	51366	.unused,
	51367	.unused,
	51368	.unused,
	51369	.unused,
	51370	},
	51371	.dst_temps = .{.{ .rc = .sse }},
	51372	.each = .{ .once = &.{
	51373	.{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
	51374	.{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51375	.{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	51376	} },
	51377	}, .{
	51378	.required_features = .{ .sse2, null, null, null },
	51379	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	51380	.dst_constraints = .{.{ .float = .qword }},
	51381	.patterns = &.{
	51382	.{ .src = .{ .mem, .none, .none } },
	51383	.{ .src = .{ .to_gpr, .none, .none } },
	51384	},
	51385	.extra_temps = .{
	51386	.{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51387	.unused,
	51388	.unused,
	51389	.unused,
	51390	.unused,
	51391	.unused,
	51392	.unused,
	51393	.unused,
	51394	.unused,
	51395	},
	51396	.dst_temps = .{.{ .rc = .sse }},
	51397	.each = .{ .once = &.{
	51398	.{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
	51399	.{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
	51400	.{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
	51401	} },
	51402	}, .{
	51403	.required_features = .{ .avx, null, null, null },
	51404	.src_constraints = .{ .{ .signed_int = .word }, .any, .any },
	51405	.dst_constraints = .{.{ .float = .qword }},
	51406	.patterns = &.{
	51407	.{ .src = .{ .mem, .none, .none } },
	51408	.{ .src = .{ .to_gpr, .none, .none } },
	51409	},
	51410	.extra_temps = .{
	51411	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51412	.unused,
	51413	.unused,
	51414	.unused,
	51415	.unused,
	51416	.unused,
	51417	.unused,
	51418	.unused,
	51419	.unused,
	51420	},
	51421	.dst_temps = .{.{ .rc = .sse }},
	51422	.each = .{ .once = &.{
	51423	.{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
	51424	.{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51425	.{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	51426	} },
	51427	}, .{
	51428	.required_features = .{ .sse2, null, null, null },
	51429	.src_constraints = .{ .{ .signed_int = .word }, .any, .any },
	51430	.dst_constraints = .{.{ .float = .qword }},
	51431	.patterns = &.{
	51432	.{ .src = .{ .mem, .none, .none } },
	51433	.{ .src = .{ .to_gpr, .none, .none } },
	51434	},
	51435	.extra_temps = .{
	51436	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51437	.unused,
	51438	.unused,
	51439	.unused,
	51440	.unused,
	51441	.unused,
	51442	.unused,
	51443	.unused,
	51444	.unused,
	51445	},
	51446	.dst_temps = .{.{ .rc = .sse }},
	51447	.each = .{ .once = &.{
	51448	.{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
	51449	.{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
	51450	.{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
	51451	} },
	51452	}, .{
	51453	.required_features = .{ .avx, null, null, null },
	51454	.src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
	51455	.dst_constraints = .{.{ .float = .qword }},
	51456	.patterns = &.{
	51457	.{ .src = .{ .mem, .none, .none } },
	51458	.{ .src = .{ .to_gpr, .none, .none } },
	51459	},
	51460	.extra_temps = .{
	51461	.{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51462	.unused,
	51463	.unused,
	51464	.unused,
	51465	.unused,
	51466	.unused,
	51467	.unused,
	51468	.unused,
	51469	.unused,
	51470	},
	51471	.dst_temps = .{.{ .rc = .sse }},
	51472	.each = .{ .once = &.{
	51473	.{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
	51474	.{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51475	.{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ },
	51476	} },
	51477	}, .{
	51478	.required_features = .{ .sse2, null, null, null },
	51479	.src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
	51480	.dst_constraints = .{.{ .float = .qword }},
	51481	.patterns = &.{
	51482	.{ .src = .{ .mem, .none, .none } },
	51483	.{ .src = .{ .to_gpr, .none, .none } },
	51484	},
	51485	.extra_temps = .{
	51486	.{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51487	.unused,
	51488	.unused,
	51489	.unused,
	51490	.unused,
	51491	.unused,
	51492	.unused,
	51493	.unused,
	51494	.unused,
	51495	},
	51496	.dst_temps = .{.{ .rc = .sse }},
	51497	.each = .{ .once = &.{
	51498	.{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
	51499	.{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
	51500	.{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ },
	51501	} },
	51502	}, .{
	51503	.required_features = .{ .avx, null, null, null },
	51504	.src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
	51505	.dst_constraints = .{.{ .float = .qword }},
	51506	.patterns = &.{
	51507	.{ .src = .{ .mem, .none, .none } },
	51508	.{ .src = .{ .to_gpr, .none, .none } },
	51509	},
	51510	.dst_temps = .{.{ .rc = .sse }},
	51511	.each = .{ .once = &.{
	51512	.{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51513	.{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0d, ._ },
	51514	} },
	51515	}, .{
	51516	.required_features = .{ .sse2, null, null, null },
	51517	.src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
	51518	.dst_constraints = .{.{ .float = .qword }},
	51519	.patterns = &.{
	51520	.{ .src = .{ .mem, .none, .none } },
	51521	.{ .src = .{ .to_gpr, .none, .none } },
	51522	},
	51523	.dst_temps = .{.{ .rc = .sse }},
	51524	.each = .{ .once = &.{
	51525	.{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
	51526	.{ ._, ._sd, .cvtsi2, .dst0x, .src0d, ._, ._ },
	51527	} },
	51528	}, .{
	51529	.required_features = .{ .avx, null, null, null },
	51530	.src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
	51531	.dst_constraints = .{.{ .float = .qword }},
	51532	.patterns = &.{
	51533	.{ .src = .{ .mem, .none, .none } },
	51534	.{ .src = .{ .to_gpr, .none, .none } },
	51535	},
	51536	.extra_temps = .{
	51537	.{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51538	.unused,
	51539	.unused,
	51540	.unused,
	51541	.unused,
	51542	.unused,
	51543	.unused,
	51544	.unused,
	51545	.unused,
	51546	},
	51547	.dst_temps = .{.{ .rc = .sse }},
	51548	.each = .{ .once = &.{
	51549	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	51550	.{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51551	.{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ },
	51552	} },
	51553	}, .{
	51554	.required_features = .{ .sse2, null, null, null },
	51555	.src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
	51556	.dst_constraints = .{.{ .float = .qword }},
	51557	.patterns = &.{
	51558	.{ .src = .{ .mem, .none, .none } },
	51559	.{ .src = .{ .to_gpr, .none, .none } },
	51560	},
	51561	.extra_temps = .{
	51562	.{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51563	.unused,
	51564	.unused,
	51565	.unused,
	51566	.unused,
	51567	.unused,
	51568	.unused,
	51569	.unused,
	51570	.unused,
	51571	},
	51572	.dst_temps = .{.{ .rc = .sse }},
	51573	.each = .{ .once = &.{
	51574	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	51575	.{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
	51576	.{ ._, ._sd, .cvtsi2, .dst0x, .tmp0q, ._, ._ },
	51577	} },
	51578	}, .{
	51579	.required_features = .{ .x87, null, null, null },
	51580	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	51581	.dst_constraints = .{.{ .float = .qword }},
	51582	.patterns = &.{
	51583	.{ .src = .{ .mem, .none, .none } },
	51584	.{ .src = .{ .to_gpr, .none, .none } },
	51585	},
	51586	.extra_temps = .{
	51587	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51588	.{ .type = .i16, .kind = .mem },
	51589	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	51590	.unused,
	51591	.unused,
	51592	.unused,
	51593	.unused,
	51594	.unused,
	51595	.unused,
	51596	},
	51597	.dst_temps = .{.mem},
	51598	.each = .{ .once = &.{
	51599	.{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
	51600	.{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ },
	51601	.{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ },
	51602	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
	51603	} },
	51604	}, .{
	51605	.required_features = .{ .x87, null, null, null },
	51606	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	51607	.dst_constraints = .{.{ .float = .qword }},
	51608	.patterns = &.{
	51609	.{ .src = .{ .mem, .none, .none } },
	51610	.{ .src = .{ .to_gpr, .none, .none } },
	51611	},
	51612	.extra_temps = .{
	51613	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51614	.{ .type = .i16, .kind = .mem },
	51615	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	51616	.unused,
	51617	.unused,
	51618	.unused,
	51619	.unused,
	51620	.unused,
	51621	.unused,
	51622	},
	51623	.dst_temps = .{.mem},
	51624	.each = .{ .once = &.{
	51625	.{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
	51626	.{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ },
	51627	.{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ },
	51628	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
	51629	} },
	51630	}, .{
	51631	.required_features = .{ .x87, null, null, null },
	51632	.src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any },
	51633	.dst_constraints = .{.{ .float = .qword }},
	51634	.patterns = &.{
	51635	.{ .src = .{ .to_mem, .none, .none } },
	51636	},
	51637	.extra_temps = .{
	51638	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	51639	.unused,
	51640	.unused,
	51641	.unused,
	51642	.unused,
	51643	.unused,
	51644	.unused,
	51645	.unused,
	51646	.unused,
	51647	},
	51648	.dst_temps = .{.mem},
	51649	.each = .{ .once = &.{
	51650	.{ ._, .fi_, .ld, .src0w, ._, ._, ._ },
	51651	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
	51652	} },
	51653	}, .{
	51654	.required_features = .{ .x87, null, null, null },
	51655	.src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any },
	51656	.dst_constraints = .{.{ .float = .qword }},
	51657	.patterns = &.{
	51658	.{ .src = .{ .mem, .none, .none } },
	51659	.{ .src = .{ .to_gpr, .none, .none } },
	51660	},
	51661	.extra_temps = .{
	51662	.{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51663	.{ .type = .i32, .kind = .mem },
	51664	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	51665	.unused,
	51666	.unused,
	51667	.unused,
	51668	.unused,
	51669	.unused,
	51670	.unused,
	51671	},
	51672	.dst_temps = .{.mem},
	51673	.each = .{ .once = &.{
	51674	.{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
	51675	.{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
	51676	.{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ },
	51677	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
	51678	} },
	51679	}, .{
	51680	.required_features = .{ .x87, null, null, null },
	51681	.src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
	51682	.dst_constraints = .{.{ .float = .qword }},
	51683	.patterns = &.{
	51684	.{ .src = .{ .to_mem, .none, .none } },
	51685	},
	51686	.extra_temps = .{
	51687	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	51688	.unused,
	51689	.unused,
	51690	.unused,
	51691	.unused,
	51692	.unused,
	51693	.unused,
	51694	.unused,
	51695	.unused,
	51696	},
	51697	.dst_temps = .{.mem},
	51698	.each = .{ .once = &.{
	51699	.{ ._, .fi_, .ld, .src0d, ._, ._, ._ },
	51700	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
	51701	} },
	51702	}, .{
	51703	.required_features = .{ .@"64bit", .x87, null, null },
	51704	.src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
	51705	.dst_constraints = .{.{ .float = .qword }},
	51706	.patterns = &.{
	51707	.{ .src = .{ .mem, .none, .none } },
	51708	.{ .src = .{ .to_gpr, .none, .none } },
	51709	},
	51710	.extra_temps = .{
	51711	.{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51712	.{ .type = .i64, .kind = .mem },
	51713	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	51714	.unused,
	51715	.unused,
	51716	.unused,
	51717	.unused,
	51718	.unused,
	51719	.unused,
	51720	},
	51721	.dst_temps = .{.mem},
	51722	.each = .{ .once = &.{
	51723	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	51724	.{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
	51725	.{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ },
	51726	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
	51727	} },
	51728	}, .{
	51729	.required_features = .{ .@"64bit", .avx, null, null },
	51730	.src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
	51731	.dst_constraints = .{.{ .float = .qword }},
	51732	.patterns = &.{
	51733	.{ .src = .{ .mem, .none, .none } },
	51734	.{ .src = .{ .to_gpr, .none, .none } },
	51735	},
	51736	.dst_temps = .{.{ .rc = .sse }},
	51737	.each = .{ .once = &.{
	51738	.{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ },
	51739	.{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0q, ._ },
	51740	} },
	51741	}, .{
	51742	.required_features = .{ .@"64bit", .sse2, null, null },
	51743	.src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
	51744	.dst_constraints = .{.{ .float = .qword }},
	51745	.patterns = &.{
	51746	.{ .src = .{ .mem, .none, .none } },
	51747	.{ .src = .{ .to_gpr, .none, .none } },
	51748	},
	51749	.dst_temps = .{.{ .rc = .sse }},
	51750	.each = .{ .once = &.{
	51751	.{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ },
	51752	.{ ._, ._sd, .cvtsi2, .dst0x, .src0q, ._, ._ },
	51753	} },
	51754	}, .{
	51755	.required_features = .{ .@"64bit", .avx, null, null },
	51756	.src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
	51757	.dst_constraints = .{.{ .float = .qword }},
	51758	.patterns = &.{
	51759	.{ .src = .{ .mem, .none, .none } },
	51760	.{ .src = .{ .to_gpr, .none, .none } },
	51761	},
	51762	.extra_temps = .{
	51763	.{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
	51764	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
	51765	.{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem },
	51766	.{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem },
	51767	.unused,
	51768	.unused,
	51769	.unused,
	51770	.unused,
	51771	.unused,
	51772	},
	51773	.dst_temps = .{.{ .rc = .sse }},
	51774	.each = .{ .once = &.{
	51775	.{ ._, .v_q, .mov, .tmp0x, .src0q, ._, ._ },
	51776	.{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
	51777	.{ ._, .vp_, .unpckldq, .tmp0x, .tmp0x, .lea(.tmp1x), ._ },
	51778	.{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
	51779	.{ ._, .v_pd, .sub, .tmp0x, .tmp0x, .lea(.tmp1x), ._ },
	51780	.{ ._, .v_pd, .unpckh, .dst0x, .tmp0x, .tmp0x, ._ },
	51781	.{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp0x, ._ },
	51782	} },
	51783	}, .{
	51784	.required_features = .{ .@"64bit", .sse2, null, null },
	51785	.src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
	51786	.dst_constraints = .{.{ .float = .qword }},
	51787	.patterns = &.{
	51788	.{ .src = .{ .mem, .none, .none } },
	51789	.{ .src = .{ .to_gpr, .none, .none } },
	51790	},
	51791	.extra_temps = .{
	51792	.{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
	51793	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
	51794	.{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem },
	51795	.{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem },
	51796	.unused,
	51797	.unused,
	51798	.unused,
	51799	.unused,
	51800	.unused,
	51801	},
	51802	.dst_temps = .{.{ .rc = .sse }},
	51803	.each = .{ .once = &.{
	51804	.{ ._, ._q, .mov, .tmp0x, .src0q, ._, ._ },
	51805	.{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ },
	51806	.{ ._, .p_, .unpckldq, .tmp0x, .lea(.tmp1x), ._, ._ },
	51807	.{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ },
	51808	.{ ._, ._pd, .sub, .tmp0x, .lea(.tmp1x), ._, ._ },
	51809	.{ ._, ._pd, .mova, .dst0x, .tmp0x, ._, ._ },
	51810	.{ ._, ._pd, .unpckh, .dst0x, .dst0x, ._, ._ },
	51811	.{ ._, ._sd, .add, .dst0x, .tmp0x, ._, ._ },
	51812	} },
	51813	}, .{
	51814	.required_features = .{ .x87, null, null, null },
	51815	.src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
	51816	.dst_constraints = .{.{ .float = .qword }},
	51817	.patterns = &.{
	51818	.{ .src = .{ .to_mem, .none, .none } },
	51819	},
	51820	.extra_temps = .{
	51821	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	51822	.unused,
	51823	.unused,
	51824	.unused,
	51825	.unused,
	51826	.unused,
	51827	.unused,
	51828	.unused,
	51829	.unused,
	51830	},
	51831	.dst_temps = .{.mem},
	51832	.each = .{ .once = &.{
	51833	.{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
	51834	.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
	51835	} },
	51836	}, .{
	51837	.required_features = .{ .@"64bit", .x87, null, null },
	51838	.src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
	51839	.dst_constraints = .{.{ .float = .qword }},
	51840	.patterns = &.{
	51841	.{ .src = .{ .to_mut_gpr, .none, .none } },
	51842	},
	51843	.extra_temps = .{
	51844	.{ .type = .u1, .kind = .{ .rc = .general_purpose } },
	51845	.{ .type = .f64, .kind = .{ .reg = .st7 } },
	51846	.unused,
	51847	.unused,
	51848	.unused,
	51849	.unused,
	51850	.unused,
	51851	.unused,
	51852	.unused,
	51853	},
	51854	.dst_temps = .{.mem},
	51855	.clobbers = .{ .eflags = true },
	51856	.each = .{ .once = &.{
	51857	.{ ._, ._, .@"test", .src0q, .src0q, ._, ._ },
	51858	.{ ._, ._ns, .j, .@"1f", ._, ._, ._ },
	51859	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	51860	.{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ },
	51861	.{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ },
	51862	.{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ },
	51863	.{ ._, ._, .mov, .dst0q, .src0q, ._, ._ },
	51864	.{ ._, .fi_, .ld, .dst0q, ._, ._, ._ },
	51865	.{ ._, .f_, .add, .tmp1t, .tmp1t, ._, ._ },
	51866	.{ ._, ._mp, .j, .@"0f", ._, ._, ._ },
	51867	.{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ },
	51868	.{ .@"1:", ._, .mov, .dst0q, .src0q, ._, ._ },
	51869	.{ ._, .fi_, .ld, .dst0q, ._, ._, ._ },
	51870	.{ .@"0:", .f_p, .st, .dst0q, ._, ._, ._ },
	51871	} },
	51872	}, .{
	51873	.required_features = .{ .@"64bit", .sse, null, null },
	51874	.src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
	51875	.dst_constraints = .{.{ .float = .qword }},
	51876	.patterns = &.{
	51877	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	51878	},
	51879	.call_frame = .{ .alignment = .@"16" },
	51880	.extra_temps = .{
	51881	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattidf" } } },
	51882	.unused,
	51883	.unused,
	51884	.unused,
	51885	.unused,
	51886	.unused,
	51887	.unused,
	51888	.unused,
	51889	.unused,
	51890	},
	51891	.dst_temps = .{.{ .reg = .xmm0 }},
	51892	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	51893	.each = .{ .once = &.{
	51894	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	51895	} },
	51896	}, .{
	51897	.required_features = .{ .@"64bit", .sse, null, null },
	51898	.src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
	51899	.dst_constraints = .{.{ .float = .qword }},
	51900	.patterns = &.{
	51901	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	51902	},
	51903	.call_frame = .{ .alignment = .@"16" },
	51904	.extra_temps = .{
	51905	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntidf" } } },
	51906	.unused,
	51907	.unused,
	51908	.unused,
	51909	.unused,
	51910	.unused,
	51911	.unused,
	51912	.unused,
	51913	.unused,
	51914	},
	51915	.dst_temps = .{.{ .reg = .xmm0 }},
	51916	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	51917	.each = .{ .once = &.{
	51918	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	51919	} },
	51920	}, .{
	51921	.required_features = .{ .@"64bit", .sse, null, null },
	51922	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	51923	.dst_constraints = .{.{ .float = .qword }},
	51924	.patterns = &.{
	51925	.{ .src = .{ .to_mem, .none, .none } },
	51926	},
	51927	.call_frame = .{ .alignment = .@"16" },
	51928	.extra_temps = .{
	51929	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	51930	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	51931	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateidf" } } },
	51932	.unused,
	51933	.unused,
	51934	.unused,
	51935	.unused,
	51936	.unused,
	51937	.unused,
	51938	},
	51939	.dst_temps = .{.{ .reg = .xmm0 }},
	51940	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	51941	.each = .{ .once = &.{
	51942	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	51943	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	51944	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	51945	} },
	51946	}, .{
	51947	.required_features = .{ .@"64bit", .sse, null, null },
	51948	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	51949	.dst_constraints = .{.{ .float = .qword }},
	51950	.patterns = &.{
	51951	.{ .src = .{ .to_mem, .none, .none } },
	51952	},
	51953	.call_frame = .{ .alignment = .@"16" },
	51954	.extra_temps = .{
	51955	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	51956	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	51957	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneidf" } } },
	51958	.unused,
	51959	.unused,
	51960	.unused,
	51961	.unused,
	51962	.unused,
	51963	.unused,
	51964	},
	51965	.dst_temps = .{.{ .reg = .xmm0 }},
	51966	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	51967	.each = .{ .once = &.{
	51968	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	51969	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	51970	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	51971	} },
	51972	}, .{
	51973	.required_features = .{ .x87, null, null, null },
	51974	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	51975	.dst_constraints = .{.{ .float = .tbyte }},
	51976	.patterns = &.{
	51977	.{ .src = .{ .mem, .none, .none } },
	51978	.{ .src = .{ .to_gpr, .none, .none } },
	51979	},
	51980	.extra_temps = .{
	51981	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	51982	.{ .type = .i16, .kind = .mem },
	51983	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	51984	.unused,
	51985	.unused,
	51986	.unused,
	51987	.unused,
	51988	.unused,
	51989	.unused,
	51990	},
	51991	.dst_temps = .{.{ .rc = .x87 }},
	51992	.each = .{ .once = &.{
	51993	.{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
	51994	.{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ },
	51995	.{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ },
	51996	.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
	51997	} },
	51998	}, .{
	51999	.required_features = .{ .x87, null, null, null },
	52000	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	52001	.dst_constraints = .{.{ .float = .tbyte }},
	52002	.patterns = &.{
	52003	.{ .src = .{ .mem, .none, .none } },
	52004	.{ .src = .{ .to_gpr, .none, .none } },
	52005	},
	52006	.extra_temps = .{
	52007	.{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	52008	.{ .type = .i16, .kind = .mem },
	52009	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	52010	.unused,
	52011	.unused,
	52012	.unused,
	52013	.unused,
	52014	.unused,
	52015	.unused,
	52016	},
	52017	.dst_temps = .{.{ .rc = .x87 }},
	52018	.each = .{ .once = &.{
	52019	.{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
	52020	.{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ },
	52021	.{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ },
	52022	.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
	52023	} },
	52024	}, .{
	52025	.required_features = .{ .x87, null, null, null },
	52026	.src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any },
	52027	.dst_constraints = .{.{ .float = .tbyte }},
	52028	.patterns = &.{
	52029	.{ .src = .{ .to_mem, .none, .none } },
	52030	},
	52031	.extra_temps = .{
	52032	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	52033	.unused,
	52034	.unused,
	52035	.unused,
	52036	.unused,
	52037	.unused,
	52038	.unused,
	52039	.unused,
	52040	.unused,
	52041	},
	52042	.dst_temps = .{.{ .rc = .x87 }},
	52043	.each = .{ .once = &.{
	52044	.{ ._, .fi_, .ld, .src0w, ._, ._, ._ },
	52045	.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
	52046	} },
	52047	}, .{
	52048	.required_features = .{ .x87, null, null, null },
	52049	.src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any },
	52050	.dst_constraints = .{.{ .float = .tbyte }},
	52051	.patterns = &.{
	52052	.{ .src = .{ .mem, .none, .none } },
	52053	.{ .src = .{ .to_gpr, .none, .none } },
	52054	},
	52055	.extra_temps = .{
	52056	.{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	52057	.{ .type = .i32, .kind = .mem },
	52058	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	52059	.unused,
	52060	.unused,
	52061	.unused,
	52062	.unused,
	52063	.unused,
	52064	.unused,
	52065	},
	52066	.dst_temps = .{.{ .rc = .x87 }},
	52067	.each = .{ .once = &.{
	52068	.{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
	52069	.{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ },
	52070	.{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ },
	52071	.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
	52072	} },
	52073	}, .{
	52074	.required_features = .{ .x87, null, null, null },
	52075	.src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any },
	52076	.dst_constraints = .{.{ .float = .tbyte }},
	52077	.patterns = &.{
	52078	.{ .src = .{ .to_mem, .none, .none } },
	52079	},
	52080	.extra_temps = .{
	52081	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	52082	.unused,
	52083	.unused,
	52084	.unused,
	52085	.unused,
	52086	.unused,
	52087	.unused,
	52088	.unused,
	52089	.unused,
	52090	},
	52091	.dst_temps = .{.{ .rc = .x87 }},
	52092	.each = .{ .once = &.{
	52093	.{ ._, .fi_, .ld, .src0d, ._, ._, ._ },
	52094	.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
	52095	} },
	52096	}, .{
	52097	.required_features = .{ .@"64bit", .x87, null, null },
	52098	.src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any },
	52099	.dst_constraints = .{.{ .float = .tbyte }},
	52100	.patterns = &.{
	52101	.{ .src = .{ .mem, .none, .none } },
	52102	.{ .src = .{ .to_gpr, .none, .none } },
	52103	},
	52104	.extra_temps = .{
	52105	.{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } },
	52106	.{ .type = .i64, .kind = .mem },
	52107	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	52108	.unused,
	52109	.unused,
	52110	.unused,
	52111	.unused,
	52112	.unused,
	52113	.unused,
	52114	},
	52115	.dst_temps = .{.{ .rc = .x87 }},
	52116	.each = .{ .once = &.{
	52117	.{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ },
	52118	.{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ },
	52119	.{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ },
	52120	.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
	52121	} },
	52122	}, .{
	52123	.required_features = .{ .x87, null, null, null },
	52124	.src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any },
	52125	.dst_constraints = .{.{ .float = .tbyte }},
	52126	.patterns = &.{
	52127	.{ .src = .{ .to_mem, .none, .none } },
	52128	},
	52129	.extra_temps = .{
	52130	.{ .type = .f80, .kind = .{ .reg = .st7 } },
	52131	.unused,
	52132	.unused,
	52133	.unused,
	52134	.unused,
	52135	.unused,
	52136	.unused,
	52137	.unused,
	52138	.unused,
	52139	},
	52140	.dst_temps = .{.{ .rc = .x87 }},
	52141	.each = .{ .once = &.{
	52142	.{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
	52143	.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
	52144	} },
	52145	}, .{
	52146	.required_features = .{ .x87, null, null, null },
	52147	.src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any },
	52148	.dst_constraints = .{.{ .float = .tbyte }},
	52149	.patterns = &.{
	52150	.{ .src = .{ .to_mem, .none, .none } },
	52151	},
	52152	.extra_temps = .{
	52153	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
	52154	.{ .type = .u1, .kind = .{ .rc = .general_purpose } },
	52155	.{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem },
	52156	.unused,
	52157	.unused,
	52158	.unused,
	52159	.unused,
	52160	.unused,
	52161	.unused,
	52162	},
	52163	.dst_temps = .{.{ .rc = .x87 }},
	52164	.clobbers = .{ .eflags = true },
	52165	.each = .{ .once = &.{
	52166	.{ ._, .fi_, .ld, .src0q, ._, ._, ._ },
	52167	.{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ },
	52168	.{ ._, ._, .mov, .tmp1d, .memd(.src0d, 4), ._, ._ },
	52169	.{ ._, ._r, .sh, .tmp1d, .ui(31), ._, ._ },
	52170	.{ ._, .f_, .add, .leasi(.tmp0d, .@"4", .tmp1), ._, ._, ._ },
	52171	.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
	52172	} },
	52173	}, .{
	52174	.required_features = .{ .@"64bit", .sse, null, null },
	52175	.src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
	52176	.dst_constraints = .{.{ .float = .tbyte }},
	52177	.patterns = &.{
	52178	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	52179	},
	52180	.call_frame = .{ .alignment = .@"16" },
	52181	.extra_temps = .{
	52182	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattixf" } } },
	52183	.unused,
	52184	.unused,
	52185	.unused,
	52186	.unused,
	52187	.unused,
	52188	.unused,
	52189	.unused,
	52190	.unused,
	52191	},
	52192	.dst_temps = .{.{ .reg = .st0 }},
	52193	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52194	.each = .{ .once = &.{
	52195	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52196	} },
	52197	}, .{
	52198	.required_features = .{ .@"64bit", .sse, null, null },
	52199	.src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
	52200	.dst_constraints = .{.{ .float = .tbyte }},
	52201	.patterns = &.{
	52202	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	52203	},
	52204	.call_frame = .{ .alignment = .@"16" },
	52205	.extra_temps = .{
	52206	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntixf" } } },
	52207	.unused,
	52208	.unused,
	52209	.unused,
	52210	.unused,
	52211	.unused,
	52212	.unused,
	52213	.unused,
	52214	.unused,
	52215	},
	52216	.dst_temps = .{.{ .reg = .st0 }},
	52217	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52218	.each = .{ .once = &.{
	52219	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52220	} },
	52221	}, .{
	52222	.required_features = .{ .@"64bit", .sse, null, null },
	52223	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	52224	.dst_constraints = .{.{ .float = .tbyte }},
	52225	.patterns = &.{
	52226	.{ .src = .{ .to_mem, .none, .none } },
	52227	},
	52228	.call_frame = .{ .alignment = .@"16" },
	52229	.extra_temps = .{
	52230	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	52231	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	52232	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateixf" } } },
	52233	.unused,
	52234	.unused,
	52235	.unused,
	52236	.unused,
	52237	.unused,
	52238	.unused,
	52239	},
	52240	.dst_temps = .{.{ .reg = .st0 }},
	52241	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52242	.each = .{ .once = &.{
	52243	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	52244	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	52245	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	52246	} },
	52247	}, .{
	52248	.required_features = .{ .@"64bit", .sse, null, null },
	52249	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	52250	.dst_constraints = .{.{ .float = .tbyte }},
	52251	.patterns = &.{
	52252	.{ .src = .{ .to_mem, .none, .none } },
	52253	},
	52254	.call_frame = .{ .alignment = .@"16" },
	52255	.extra_temps = .{
	52256	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	52257	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	52258	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneixf" } } },
	52259	.unused,
	52260	.unused,
	52261	.unused,
	52262	.unused,
	52263	.unused,
	52264	.unused,
	52265	},
	52266	.dst_temps = .{.{ .reg = .st0 }},
	52267	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52268	.each = .{ .once = &.{
	52269	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	52270	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	52271	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	52272	} },
	52273	}, .{
	52274	.required_features = .{ .sse, null, null, null },
	52275	.src_constraints = .{ .{ .signed_int = .byte }, .any, .any },
	52276	.dst_constraints = .{.{ .float = .xword }},
	52277	.patterns = &.{
	52278	.{ .src = .{ .mem, .none, .none } },
	52279	.{ .src = .{ .to_gpr, .none, .none } },
	52280	},
	52281	.call_frame = .{ .alignment = .@"16" },
	52282	.extra_temps = .{
	52283	.{ .type = .i32, .kind = .{ .reg = .edi } },
	52284	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } },
	52285	.unused,
	52286	.unused,
	52287	.unused,
	52288	.unused,
	52289	.unused,
	52290	.unused,
	52291	.unused,
	52292	},
	52293	.dst_temps = .{.{ .reg = .xmm0 }},
	52294	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52295	.each = .{ .once = &.{
	52296	.{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ },
	52297	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	52298	} },
	52299	}, .{
	52300	.required_features = .{ .sse, null, null, null },
	52301	.src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any },
	52302	.dst_constraints = .{.{ .float = .xword }},
	52303	.patterns = &.{
	52304	.{ .src = .{ .mem, .none, .none } },
	52305	.{ .src = .{ .to_gpr, .none, .none } },
	52306	},
	52307	.call_frame = .{ .alignment = .@"16" },
	52308	.extra_temps = .{
	52309	.{ .type = .u32, .kind = .{ .reg = .edi } },
	52310	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } },
	52311	.unused,
	52312	.unused,
	52313	.unused,
	52314	.unused,
	52315	.unused,
	52316	.unused,
	52317	.unused,
	52318	},
	52319	.dst_temps = .{.{ .reg = .xmm0 }},
	52320	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52321	.each = .{ .once = &.{
	52322	.{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ },
	52323	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	52324	} },
	52325	}, .{
	52326	.required_features = .{ .sse, null, null, null },
	52327	.src_constraints = .{ .{ .signed_int = .word }, .any, .any },
	52328	.dst_constraints = .{.{ .float = .xword }},
	52329	.patterns = &.{
	52330	.{ .src = .{ .mem, .none, .none } },
	52331	.{ .src = .{ .to_gpr, .none, .none } },
	52332	},
	52333	.call_frame = .{ .alignment = .@"16" },
	52334	.extra_temps = .{
	52335	.{ .type = .i32, .kind = .{ .reg = .edi } },
	52336	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } },
	52337	.unused,
	52338	.unused,
	52339	.unused,
	52340	.unused,
	52341	.unused,
	52342	.unused,
	52343	.unused,
	52344	},
	52345	.dst_temps = .{.{ .reg = .xmm0 }},
	52346	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52347	.each = .{ .once = &.{
	52348	.{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ },
	52349	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	52350	} },
	52351	}, .{
	52352	.required_features = .{ .sse, null, null, null },
	52353	.src_constraints = .{ .{ .unsigned_int = .word }, .any, .any },
	52354	.dst_constraints = .{.{ .float = .xword }},
	52355	.patterns = &.{
	52356	.{ .src = .{ .mem, .none, .none } },
	52357	.{ .src = .{ .to_gpr, .none, .none } },
	52358	},
	52359	.call_frame = .{ .alignment = .@"16" },
	52360	.extra_temps = .{
	52361	.{ .type = .u32, .kind = .{ .reg = .edi } },
	52362	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } },
	52363	.unused,
	52364	.unused,
	52365	.unused,
	52366	.unused,
	52367	.unused,
	52368	.unused,
	52369	.unused,
	52370	},
	52371	.dst_temps = .{.{ .reg = .xmm0 }},
	52372	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52373	.each = .{ .once = &.{
	52374	.{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ },
	52375	.{ ._, ._, .call, .tmp1d, ._, ._, ._ },
	52376	} },
	52377	}, .{
	52378	.required_features = .{ .sse, null, null, null },
	52379	.src_constraints = .{ .{ .signed_int = .dword }, .any, .any },
	52380	.dst_constraints = .{.{ .float = .xword }},
	52381	.patterns = &.{
	52382	.{ .src = .{ .{ .to_reg = .edi }, .none, .none } },
	52383	},
	52384	.call_frame = .{ .alignment = .@"16" },
	52385	.extra_temps = .{
	52386	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } },
	52387	.unused,
	52388	.unused,
	52389	.unused,
	52390	.unused,
	52391	.unused,
	52392	.unused,
	52393	.unused,
	52394	.unused,
	52395	},
	52396	.dst_temps = .{.{ .reg = .xmm0 }},
	52397	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52398	.each = .{ .once = &.{
	52399	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52400	} },
	52401	}, .{
	52402	.required_features = .{ .sse, null, null, null },
	52403	.src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any },
	52404	.dst_constraints = .{.{ .float = .xword }},
	52405	.patterns = &.{
	52406	.{ .src = .{ .{ .to_reg = .edi }, .none, .none } },
	52407	},
	52408	.call_frame = .{ .alignment = .@"16" },
	52409	.extra_temps = .{
	52410	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } },
	52411	.unused,
	52412	.unused,
	52413	.unused,
	52414	.unused,
	52415	.unused,
	52416	.unused,
	52417	.unused,
	52418	.unused,
	52419	},
	52420	.dst_temps = .{.{ .reg = .xmm0 }},
	52421	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52422	.each = .{ .once = &.{
	52423	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52424	} },
	52425	}, .{
	52426	.required_features = .{ .@"64bit", .sse, null, null },
	52427	.src_constraints = .{ .{ .signed_int = .qword }, .any, .any },
	52428	.dst_constraints = .{.{ .float = .xword }},
	52429	.patterns = &.{
	52430	.{ .src = .{ .{ .to_reg = .rdi }, .none, .none } },
	52431	},
	52432	.call_frame = .{ .alignment = .@"16" },
	52433	.extra_temps = .{
	52434	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } },
	52435	.unused,
	52436	.unused,
	52437	.unused,
	52438	.unused,
	52439	.unused,
	52440	.unused,
	52441	.unused,
	52442	.unused,
	52443	},
	52444	.dst_temps = .{.{ .reg = .xmm0 }},
	52445	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52446	.each = .{ .once = &.{
	52447	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52448	} },
	52449	}, .{
	52450	.required_features = .{ .@"64bit", .sse, null, null },
	52451	.src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any },
	52452	.dst_constraints = .{.{ .float = .xword }},
	52453	.patterns = &.{
	52454	.{ .src = .{ .{ .to_reg = .rdi }, .none, .none } },
	52455	},
	52456	.call_frame = .{ .alignment = .@"16" },
	52457	.extra_temps = .{
	52458	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } },
	52459	.unused,
	52460	.unused,
	52461	.unused,
	52462	.unused,
	52463	.unused,
	52464	.unused,
	52465	.unused,
	52466	.unused,
	52467	},
	52468	.dst_temps = .{.{ .reg = .xmm0 }},
	52469	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52470	.each = .{ .once = &.{
	52471	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52472	} },
	52473	}, .{
	52474	.required_features = .{ .@"64bit", .sse, null, null },
	52475	.src_constraints = .{ .{ .signed_int = .xword }, .any, .any },
	52476	.dst_constraints = .{.{ .float = .xword }},
	52477	.patterns = &.{
	52478	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	52479	},
	52480	.call_frame = .{ .alignment = .@"16" },
	52481	.extra_temps = .{
	52482	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } },
	52483	.unused,
	52484	.unused,
	52485	.unused,
	52486	.unused,
	52487	.unused,
	52488	.unused,
	52489	.unused,
	52490	.unused,
	52491	},
	52492	.dst_temps = .{.{ .reg = .xmm0 }},
	52493	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52494	.each = .{ .once = &.{
	52495	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52496	} },
	52497	}, .{
	52498	.required_features = .{ .@"64bit", .sse, null, null },
	52499	.src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any },
	52500	.dst_constraints = .{.{ .float = .xword }},
	52501	.patterns = &.{
	52502	.{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } },
	52503	},
	52504	.call_frame = .{ .alignment = .@"16" },
	52505	.extra_temps = .{
	52506	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } },
	52507	.unused,
	52508	.unused,
	52509	.unused,
	52510	.unused,
	52511	.unused,
	52512	.unused,
	52513	.unused,
	52514	.unused,
	52515	},
	52516	.dst_temps = .{.{ .reg = .xmm0 }},
	52517	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52518	.each = .{ .once = &.{
	52519	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52520	} },
	52521	}, .{
	52522	.required_features = .{ .@"64bit", .sse, null, null },
	52523	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	52524	.dst_constraints = .{.{ .float = .xword }},
	52525	.patterns = &.{
	52526	.{ .src = .{ .to_mem, .none, .none } },
	52527	},
	52528	.call_frame = .{ .alignment = .@"16" },
	52529	.extra_temps = .{
	52530	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	52531	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	52532	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } },
	52533	.unused,
	52534	.unused,
	52535	.unused,
	52536	.unused,
	52537	.unused,
	52538	.unused,
	52539	},
	52540	.dst_temps = .{.{ .reg = .xmm0 }},
	52541	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52542	.each = .{ .once = &.{
	52543	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	52544	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	52545	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	52546	} },
	52547	}, .{
	52548	.required_features = .{ .@"64bit", .sse, null, null },
	52549	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any },
	52550	.dst_constraints = .{.{ .float = .xword }},
	52551	.patterns = &.{
	52552	.{ .src = .{ .to_mem, .none, .none } },
	52553	},
	52554	.call_frame = .{ .alignment = .@"16" },
	52555	.extra_temps = .{
	52556	.{ .type = .usize, .kind = .{ .reg = .rdi } },
	52557	.{ .type = .usize, .kind = .{ .reg = .rsi } },
	52558	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } },
	52559	.unused,
	52560	.unused,
	52561	.unused,
	52562	.unused,
	52563	.unused,
	52564	.unused,
	52565	},
	52566	.dst_temps = .{.{ .reg = .xmm0 }},
	52567	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52568	.each = .{ .once = &.{
	52569	.{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ },
	52570	.{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ },
	52571	.{ ._, ._, .call, .tmp2d, ._, ._, ._ },
	52572	} },
	52573	} }) catch \|err\| switch (err) {
	52574	error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
	52575	@tagName(air_tag),
	52576	ty_op.ty.toType().fmt(pt),
	52577	cg.typeOf(ty_op.operand).fmt(pt),
	52578	ops[0].tracking(cg),
	52579	}),
	52580	else => \|e\| return e,
	52581	};
	52582	try res[0].finish(inst, &.{ty_op.operand}, &ops, cg);
	52583	},
	52584	.error_set_has_value => return cg.fail("TODO implement error_set_has_value", .{}),
	52585	.union_init => if (use_old) try cg.airUnionInit(inst) else {
	52586	const ty_pl = air_datas[@intFromEnum(inst)].ty_pl;
	52587	const extra = cg.air.extraData(Air.UnionInit, ty_pl.payload).data;
	52588	const union_ty = ty_pl.ty.toType();
	52589	var ops = try cg.tempsFromOperands(inst, .{extra.init});
	52590	var res = try cg.tempAllocMem(union_ty);
	52591	const union_layout = union_ty.unionGetLayout(zcu);
	52592	if (union_layout.tag_size > 0) {
	52593	var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex(
	52594	union_ty.unionTagTypeSafety(zcu).?,
	52595	extra.field_index,
	52596	));
	52597	try res.write(&tag_temp, .{
	52598	.disp = @intCast(union_layout.tagOffset()),
	52599	}, cg);
	52600	try tag_temp.die(cg);
	52601	}
	52602	try res.write(&ops[0], .{
	52603	.disp = @intCast(union_layout.payloadOffset()),
	52604	}, cg);
	52605	try res.finish(inst, &.{extra.init}, &ops, cg);
	52606	},
	52607	.mul_add => \|air_tag\| if (use_old) try cg.airMulAdd(inst) else {
	52608	const pl_op = air_datas[@intFromEnum(inst)].pl_op;
	52609	const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data;
	52610	var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs, pl_op.operand });
	52611	var res: [1]Temp = undefined;
	52612	cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
	52613	.required_features = .{ .fma, .f16c, null, null },
	52614	.src_constraints = .{
	52615	.{ .scalar_float = .{ .of = .word, .is = .word } },
	52616	.{ .scalar_float = .{ .of = .word, .is = .word } },
	52617	.{ .scalar_float = .{ .of = .word, .is = .word } },
	52618	},
	52619	.patterns = &.{
	52620	.{ .src = .{ .to_sse, .to_sse, .to_sse } },
	52621	},
	52622	.extra_temps = .{
	52623	.{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	52624	.{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	52625	.unused,
	52626	.unused,
	52627	.unused,
	52628	.unused,
	52629	.unused,
	52630	.unused,
	52631	.unused,
	52632	},
	52633	.dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }},
	52634	.each = .{ .once = &.{
	52635	.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
	52636	.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
	52637	.{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ },
	52638	.{ ._, .v_ss, .fmadd213, .dst0x, .tmp0x, .tmp1d, ._ },
	52639	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	52640	} },
	52641	}, .{
	52642	.required_features = .{ .sse, null, null, null },
	52643	.src_constraints = .{
	52644	.{ .scalar_float = .{ .of = .word, .is = .word } },
	52645	.{ .scalar_float = .{ .of = .word, .is = .word } },
	52646	.{ .scalar_float = .{ .of = .word, .is = .word } },
	52647	},
	52648	.patterns = &.{
	52649	.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } },
	52650	},
	52651	.call_frame = .{ .alignment = .@"16" },
	52652	.extra_temps = .{
	52653	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	52654	.unused,
	52655	.unused,
	52656	.unused,
	52657	.unused,
	52658	.unused,
	52659	.unused,
	52660	.unused,
	52661	.unused,
	52662	},
	52663	.dst_temps = .{.{ .ref = .src0 }},
	52664	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52665	.each = .{ .once = &.{
	52666	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	52667	} },
	52668	}, .{
	52669	.required_features = .{ .fma, .f16c, null, null },
	52670	.src_constraints = .{
	52671	.{ .scalar_float = .{ .of = .qword, .is = .word } },
	52672	.{ .scalar_float = .{ .of = .qword, .is = .word } },
	52673	.{ .scalar_float = .{ .of = .qword, .is = .word } },
	52674	},
	52675	.patterns = &.{
	52676	.{ .src = .{ .mem, .mem, .mem } },
	52677	.{ .src = .{ .to_sse, .mem, .mem } },
	52678	.{ .src = .{ .mem, .to_sse, .mem } },
	52679	.{ .src = .{ .mem, .mem, .to_sse } },
	52680	.{ .src = .{ .to_sse, .to_sse, .mem } },
	52681	.{ .src = .{ .to_sse, .mem, .to_sse } },
	52682	.{ .src = .{ .mem, .to_sse, .to_sse } },
	52683	.{ .src = .{ .to_sse, .to_sse, .to_sse } },
	52684	},
	52685	.extra_temps = .{
	52686	.{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	52687	.{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	52688	.unused,
	52689	.unused,
	52690	.unused,
	52691	.unused,
	52692	.unused,
	52693	.unused,
	52694	.unused,
	52695	},
	52696	.dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }},
	52697	.each = .{ .once = &.{
	52698	.{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
	52699	.{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
	52700	.{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ },
	52701	.{ ._, .v_ps, .fmadd213, .dst0x, .tmp0x, .tmp1x, ._ },
	52702	.{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
	52703	} },
	52704	}, .{
	52705	.required_features = .{ .fma, .f16c, null, null },
	52706	.src_constraints = .{
	52707	.{ .scalar_float = .{ .of = .xword, .is = .word } },
	52708	.{ .scalar_float = .{ .of = .xword, .is = .word } },
	52709	.{ .scalar_float = .{ .of = .xword, .is = .word } },
	52710	},
	52711	.patterns = &.{
	52712	.{ .src = .{ .mem, .mem, .mem } },
	52713	.{ .src = .{ .to_sse, .mem, .mem } },
	52714	.{ .src = .{ .mem, .to_sse, .mem } },
	52715	.{ .src = .{ .mem, .mem, .to_sse } },
	52716	.{ .src = .{ .to_sse, .to_sse, .mem } },
	52717	.{ .src = .{ .to_sse, .mem, .to_sse } },
	52718	.{ .src = .{ .mem, .to_sse, .to_sse } },
	52719	.{ .src = .{ .to_sse, .to_sse, .to_sse } },
	52720	},
	52721	.extra_temps = .{
	52722	.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	52723	.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	52724	.unused,
	52725	.unused,
	52726	.unused,
	52727	.unused,
	52728	.unused,
	52729	.unused,
	52730	.unused,
	52731	},
	52732	.dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }},
	52733	.each = .{ .once = &.{
	52734	.{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
	52735	.{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
	52736	.{ ._, .v_ps, .cvtph2, .tmp1y, .src2x, ._, ._ },
	52737	.{ ._, .v_ps, .fmadd213, .dst0y, .tmp0y, .tmp1y, ._ },
	52738	.{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
	52739	} },
	52740	}, .{
	52741	.required_features = .{ .fma, .f16c, null, null },
	52742	.src_constraints = .{
	52743	.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
	52744	.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
	52745	.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
	52746	},
	52747	.patterns = &.{
	52748	.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	52749	},
	52750	.extra_temps = .{
	52751	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	52752	.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
	52753	.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	52754	.{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } },
	52755	.unused,
	52756	.unused,
	52757	.unused,
	52758	.unused,
	52759	.unused,
	52760	},
	52761	.dst_temps = .{.mem},
	52762	.each = .{ .once = &.{
	52763	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	52764	.{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
	52765	.{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
	52766	.{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ },
	52767	.{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .tmp3y, ._ },
	52768	.{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
	52769	.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
	52770	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	52771	} },
	52772	}, .{
	52773	.required_features = .{ .avx, null, null, null },
	52774	.src_constraints = .{
	52775	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52776	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52777	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52778	},
	52779	.patterns = &.{
	52780	.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	52781	},
	52782	.call_frame = .{ .alignment = .@"16" },
	52783	.extra_temps = .{
	52784	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	52785	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	52786	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	52787	.{ .type = .f16, .kind = .{ .reg = .xmm2 } },
	52788	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	52789	.unused,
	52790	.unused,
	52791	.unused,
	52792	.unused,
	52793	},
	52794	.dst_temps = .{.mem},
	52795	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52796	.each = .{ .once = &.{
	52797	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	52798	.{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ },
	52799	.{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
	52800	.{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
	52801	.{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0) },
	52802	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	52803	.{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
	52804	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	52805	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	52806	} },
	52807	}, .{
	52808	.required_features = .{ .sse4_1, null, null, null },
	52809	.src_constraints = .{
	52810	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52811	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52812	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52813	},
	52814	.patterns = &.{
	52815	.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	52816	},
	52817	.call_frame = .{ .alignment = .@"16" },
	52818	.extra_temps = .{
	52819	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	52820	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	52821	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	52822	.{ .type = .f16, .kind = .{ .reg = .xmm2 } },
	52823	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	52824	.unused,
	52825	.unused,
	52826	.unused,
	52827	.unused,
	52828	},
	52829	.dst_temps = .{.mem},
	52830	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52831	.each = .{ .once = &.{
	52832	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	52833	.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
	52834	.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
	52835	.{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
	52836	.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	52837	.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	52838	.{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	52839	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	52840	.{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
	52841	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	52842	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	52843	} },
	52844	}, .{
	52845	.required_features = .{ .sse2, null, null, null },
	52846	.src_constraints = .{
	52847	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52848	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52849	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52850	},
	52851	.patterns = &.{
	52852	.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	52853	},
	52854	.call_frame = .{ .alignment = .@"16" },
	52855	.extra_temps = .{
	52856	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	52857	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	52858	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	52859	.{ .type = .f16, .kind = .{ .reg = .xmm2 } },
	52860	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	52861	.{ .type = .f16, .kind = .{ .reg = .ax } },
	52862	.unused,
	52863	.unused,
	52864	.unused,
	52865	},
	52866	.dst_temps = .{.mem},
	52867	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52868	.each = .{ .once = &.{
	52869	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	52870	.{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
	52871	.{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
	52872	.{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ },
	52873	.{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	52874	.{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	52875	.{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ },
	52876	.{ ._, ._, .call, .tmp4d, ._, ._, ._ },
	52877	.{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
	52878	.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
	52879	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	52880	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	52881	} },
	52882	}, .{
	52883	.required_features = .{ .sse, null, null, null },
	52884	.src_constraints = .{
	52885	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52886	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52887	.{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
	52888	},
	52889	.patterns = &.{
	52890	.{ .src = .{ .to_mem, .to_mem, .to_mem } },
	52891	},
	52892	.call_frame = .{ .alignment = .@"16" },
	52893	.extra_temps = .{
	52894	.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
	52895	.{ .type = .f16, .kind = .{ .reg = .ax } },
	52896	.{ .type = .f32, .kind = .mem },
	52897	.{ .type = .f16, .kind = .{ .reg = .xmm0 } },
	52898	.{ .type = .f16, .kind = .{ .reg = .xmm1 } },
	52899	.{ .type = .f16, .kind = .{ .reg = .xmm2 } },
	52900	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } },
	52901	.unused,
	52902	.unused,
	52903	},
	52904	.dst_temps = .{.mem},
	52905	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52906	.each = .{ .once = &.{
	52907	.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
	52908	.{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
	52909	.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
	52910	.{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
	52911	.{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
	52912	.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
	52913	.{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
	52914	.{ ._, ._, .movzx, .tmp1d, .memia(.src2w, .tmp0, .add_unaligned_size), ._, ._ },
	52915	.{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
	52916	.{ ._, ._ss, .mov, .tmp5x, .mem(.tmp2d), ._, ._ },
	52917	.{ ._, ._, .call, .tmp6d, ._, ._, ._ },
	52918	.{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
	52919	.{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
	52920	.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
	52921	.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
	52922	.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
	52923	} },
	52924	}, .{
	52925	.required_features = .{ .fma, null, null, null },
	52926	.src_constraints = .{
	52927	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52928	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52929	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52930	},
	52931	.patterns = &.{
	52932	.{ .src = .{ .to_mut_sse, .mem, .to_sse } },
	52933	.{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
	52934	.{ .src = .{ .mut_sse, .sse, .sse } },
	52935	.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	52936	},
	52937	.dst_temps = .{.{ .ref = .src0 }},
	52938	.each = .{ .once = &.{
	52939	.{ ._, .v_ss, .fmadd132, .dst0x, .src2x, .src1d, ._ },
	52940	} },
	52941	}, .{
	52942	.required_features = .{ .fma, null, null, null },
	52943	.src_constraints = .{
	52944	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52945	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52946	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52947	},
	52948	.patterns = &.{
	52949	.{ .src = .{ .to_mut_sse, .to_sse, .mem } },
	52950	.{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
	52951	.{ .src = .{ .mut_sse, .sse, .sse } },
	52952	.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	52953	},
	52954	.dst_temps = .{.{ .ref = .src0 }},
	52955	.each = .{ .once = &.{
	52956	.{ ._, .v_ss, .fmadd213, .dst0x, .src1x, .src2d, ._ },
	52957	} },
	52958	}, .{
	52959	.required_features = .{ .fma, null, null, null },
	52960	.src_constraints = .{
	52961	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52962	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52963	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52964	},
	52965	.patterns = &.{
	52966	.{ .src = .{ .to_sse, .mem, .to_mut_sse } },
	52967	.{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
	52968	.{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
	52969	},
	52970	.dst_temps = .{.{ .ref = .src2 }},
	52971	.each = .{ .once = &.{
	52972	.{ ._, .v_ss, .fmadd231, .dst0x, .src0x, .src1d, ._ },
	52973	} },
	52974	}, .{
	52975	.required_features = .{ .sse, null, null, null },
	52976	.src_constraints = .{
	52977	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52978	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52979	.{ .scalar_float = .{ .of = .dword, .is = .dword } },
	52980	},
	52981	.patterns = &.{
	52982	.{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } },
	52983	},
	52984	.call_frame = .{ .alignment = .@"16" },
	52985	.extra_temps = .{
	52986	.{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaf" } } },
	52987	.unused,
	52988	.unused,
	52989	.unused,
	52990	.unused,
	52991	.unused,
	52992	.unused,
	52993	.unused,
	52994	.unused,
	52995	},
	52996	.dst_temps = .{.{ .ref = .src0 }},
	52997	.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
	52998	.each = .{ .once = &.{
	52999	.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
	53000	} },
	53001	}, .{
	53002	.required_features = .{ .fma, null, null, null },
	53003	.src_constraints = .{
	53004	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53005	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53006	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53007	},
	53008	.patterns = &.{
	53009	.{ .src = .{ .to_mut_sse, .mem, .to_sse } },
	53010	.{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
	53011	.{ .src = .{ .mut_sse, .sse, .sse } },
	53012	.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	53013	},
	53014	.dst_temps = .{.{ .ref = .src0 }},
	53015	.each = .{ .once = &.{
	53016	.{ ._, .v_ps, .fmadd132, .dst0x, .src2x, .src1x, ._ },
	53017	} },
	53018	}, .{
	53019	.required_features = .{ .fma, null, null, null },
	53020	.src_constraints = .{
	53021	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53022	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53023	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53024	},
	53025	.patterns = &.{
	53026	.{ .src = .{ .to_mut_sse, .to_sse, .mem } },
	53027	.{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
	53028	.{ .src = .{ .mut_sse, .sse, .sse } },
	53029	.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	53030	},
	53031	.dst_temps = .{.{ .ref = .src0 }},
	53032	.each = .{ .once = &.{
	53033	.{ ._, .v_ps, .fmadd213, .dst0x, .src1x, .src2x, ._ },
	53034	} },
	53035	}, .{
	53036	.required_features = .{ .fma, null, null, null },
	53037	.src_constraints = .{
	53038	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53039	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53040	.{ .scalar_float = .{ .of = .xword, .is = .dword } },
	53041	},
	53042	.patterns = &.{
	53043	.{ .src = .{ .to_sse, .mem, .to_mut_sse } },
	53044	.{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } },
	53045	.{ .src = .{ .to_sse, .to_sse, .to_mut_sse } },
	53046	},
	53047	.dst_temps = .{.{ .ref = .src2 }},
	53048	.each = .{ .once = &.{
	53049	.{ ._, .v_ps, .fmadd231, .dst0x, .src0x, .src1x, ._ },
	53050	} },
	53051	}, .{
	53052	.required_features = .{ .fma, null, null, null },
	53053	.src_constraints = .{
	53054	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	53055	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	53056	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	53057	},
	53058	.patterns = &.{
	53059	.{ .src = .{ .to_mut_sse, .mem, .to_sse } },
	53060	.{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } },
	53061	.{ .src = .{ .mut_sse, .sse, .sse } },
	53062	.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	53063	},
	53064	.dst_temps = .{.{ .ref = .src0 }},
	53065	.each = .{ .once = &.{
	53066	.{ ._, .v_ps, .fmadd132, .dst0y, .src2y, .src1y, ._ },
	53067	} },
	53068	}, .{
	53069	.required_features = .{ .fma, null, null, null },
	53070	.src_constraints = .{
	53071	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	53072	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	53073	.{ .scalar_float = .{ .of = .yword, .is = .dword } },
	53074	},
	53075	.patterns = &.{
	53076	.{ .src = .{ .to_mut_sse, .to_sse, .mem } },
	53077	.{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } },
	53078	.{ .src = .{ .mut_sse, .sse, .sse } },
	53079	.{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } },
	53080	},
	53081	.dst_temps = .{.{ .ref = .src0 }},
49118	53082	.each = .{ .once = &.{
49119	53083	.{ ._, .v_ps, .fmadd213, .dst0y, .src1y, .src2y, ._ },
49120	53084	} },
...	...	@@ -61093,7 +65057,7 @@ fn lowerSwitchBr(
61093	65057
61094	65058	const ExpectedContents = extern struct {
61095	65059	liveness_deaths: [1 << 8 \| 1]Air.Inst.Index,
61096		bigint_limbs: [std.math.big.int.calcTwosCompLimbCount(1 << 8)]std.math.big.Limb,
	65060	bigint_limbs: [std.math.big.int.calcTwosCompLimbCount(1 << 10)]std.math.big.Limb,
61097	65061	relocs: [1 << 6]Mir.Inst.Index,
61098	65062	};
61099	65063	var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
...	...	@@ -68103,7 +72067,7 @@ const Temp = struct {
68103	72067	return cg.inst_tracking.get(temp.index).?;
68104	72068	}
68105	72069
68106		fn getOffset(temp: Temp, off: i32, cg: *CodeGen) !Temp {
	72070	fn getOffset(temp: Temp, off: i32, cg: *CodeGen) InnerError!Temp {
68107	72071	const new_temp_index = cg.next_temp_index;
68108	72072	cg.temp_type[@intFromEnum(new_temp_index)] = .usize;
68109	72073	cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
...	...	@@ -68160,7 +72124,7 @@ const Temp = struct {
68160	72124	return .{ .index = new_temp_index.toIndex() };
68161	72125	}
68162	72126
68163		fn toOffset(temp: Temp, off: i32, cg: CodeGen) !void {
	72127	fn toOffset(temp: Temp, off: i32, cg: CodeGen) InnerError!void {
68164	72128	if (off == 0) return;
68165	72129	switch (temp.unwrap(cg)) {
68166	72130	.ref, .err_ret_trace => {},
...	...	@@ -68208,7 +72172,7 @@ const Temp = struct {
68208	72172	temp.* = new_temp;
68209	72173	}
68210	72174
68211		fn getLimb(temp: Temp, limb_ty: Type, limb_index: u28, cg: *CodeGen) !Temp {
	72175	fn getLimb(temp: Temp, limb_ty: Type, limb_index: u28, cg: *CodeGen) InnerError!Temp {
68212	72176	const new_temp_index = cg.next_temp_index;
68213	72177	cg.temp_type[@intFromEnum(new_temp_index)] = limb_ty;
68214	72178	switch (temp.tracking(cg).short) {
...	...	@@ -68280,7 +72244,7 @@ const Temp = struct {
68280	72244	return .{ .index = new_temp_index.toIndex() };
68281	72245	}
68282	72246
68283		fn toLimb(temp: Temp, limb_ty: Type, limb_index: u28, cg: CodeGen) !void {
	72247	fn toLimb(temp: Temp, limb_ty: Type, limb_index: u28, cg: CodeGen) InnerError!void {
68284	72248	switch (temp.unwrap(cg)) {
68285	72249	.ref => {},
68286	72250	.temp => \|temp_index\| {
...	...	@@ -68331,38 +72295,67 @@ const Temp = struct {
68331	72295	temp.* = new_temp;
68332	72296	}
68333	72297
68334		fn toSlicePtr(temp: Temp, cg: CodeGen) !void {
	72298	fn toSlicePtr(temp: Temp, cg: CodeGen) InnerError!void {
68335	72299	const temp_ty = temp.typeOf(cg);
68336	72300	if (temp_ty.isSlice(cg.pt.zcu)) try temp.toLimb(temp_ty.slicePtrFieldType(cg.pt.zcu), 0, cg);
68337	72301	}
68338	72302
68339		fn toSliceLen(temp: Temp, cg: CodeGen) !void {
	72303	fn toSliceLen(temp: Temp, cg: CodeGen) InnerError!void {
68340	72304	try temp.toLimb(.usize, 1, cg);
68341	72305	}
68342	72306
68343		fn toReg(temp: Temp, new_reg: Register, cg: CodeGen) !bool {
68344		const val, const ty: Type = val_ty: switch (temp.unwrap(cg)) {
68345		.ref => \|ref\| .{ temp.tracking(cg).short, cg.typeOf(ref) },
	72307	fn toReg(temp: Temp, new_reg: Register, cg: CodeGen) InnerError!bool {
	72308	const ty: Type = ty: switch (temp.unwrap(cg)) {
	72309	.ref => \|ref\| cg.typeOf(ref),
68346	72310	.temp => \|temp_index\| {
68347	72311	const temp_tracking = temp_index.tracking(cg);
68348	72312	if (temp_tracking.short == .register and
68349	72313	temp_tracking.short.register == new_reg) return false;
68350		break :val_ty .{ temp_tracking.short, temp_index.typeOf(cg) };
	72314	break :ty temp_index.typeOf(cg);
68351	72315	},
68352		.err_ret_trace => .{ temp.tracking(cg).short, .usize },
	72316	.err_ret_trace => .usize,
68353	72317	};
68354	72318	const new_temp_index = cg.next_temp_index;
	72319	cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
68355	72320	try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
68356	72321	cg.temp_type[@intFromEnum(new_temp_index)] = ty;
68357		try cg.genSetReg(new_reg, ty, val, .{});
68358	72322	new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
	72323	while (try temp.toBase(cg)) {}
	72324	try temp.readTo(ty, .{ .register = new_reg }, .{}, cg);
68359	72325	try temp.die(cg);
	72326	temp.* = .{ .index = new_temp_index.toIndex() };
	72327	return true;
	72328	}
	72329
	72330	fn toRegPair(temp: Temp, new_regs: [2]Register, cg: CodeGen) InnerError!bool {
	72331	const ty: Type = ty: switch (temp.unwrap(cg)) {
	72332	.ref => \|ref\| cg.typeOf(ref),
	72333	.temp => \|temp_index\| {
	72334	const temp_tracking = temp_index.tracking(cg);
	72335	if (temp_tracking.short == .register_pair and
	72336	std.mem.eql(Register, &temp_tracking.short.register_pair, &new_regs)) return false;
	72337	break :ty temp_index.typeOf(cg);
	72338	},
	72339	.err_ret_trace => .usize,
	72340	};
	72341	const new_temp_index = cg.next_temp_index;
68360	72342	cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1);
	72343	for (new_regs) \|new_reg\| try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
	72344	cg.temp_type[@intFromEnum(new_temp_index)] = ty;
	72345	new_temp_index.tracking(cg).* = .init(.{ .register_pair = new_regs });
	72346	while (try temp.toBase(cg)) {}
	72347	for (new_regs, 0..) \|new_reg, reg_index\| try temp.readTo(
	72348	.usize,
	72349	.{ .register = new_reg },
	72350	.{ .disp = @intCast(8 * reg_index) },
	72351	cg,
	72352	);
	72353	try temp.die(cg);
68361	72354	temp.* = .{ .index = new_temp_index.toIndex() };
68362	72355	return true;
68363	72356	}
68364	72357
68365		fn toRegClass(temp: Temp, mut: bool, rc: Register.Class, cg: CodeGen) !bool {
	72358	fn toRegClass(temp: Temp, mut: bool, rc: Register.Class, cg: CodeGen) InnerError!bool {
68366	72359	const val = temp.tracking(cg).short;
68367	72360	if (!mut or temp.isMut(cg)) switch (val) {
68368	72361	else => {},
...	...	@@ -68381,7 +72374,7 @@ const Temp = struct {
68381	72374	return true;
68382	72375	}
68383	72376
68384		fn toPair(first_temp: Temp, second_temp: Temp, cg: *CodeGen) !void {
	72377	fn toPair(first_temp: Temp, second_temp: Temp, cg: *CodeGen) InnerError!void {
68385	72378	while (true) for ([_]*Temp{ first_temp, second_temp }) \|part_temp\| {
68386	72379	if (try part_temp.toRegClass(true, .general_purpose, cg)) break;
68387	72380	} else break;
...	...	@@ -68408,7 +72401,7 @@ const Temp = struct {
68408	72401	mcv.* = .{ .register_mask = .{ .reg = reg, .info = info } };
68409	72402	}
68410	72403
68411		fn toLea(temp: Temp, cg: CodeGen) !bool {
	72404	fn toLea(temp: Temp, cg: CodeGen) InnerError!bool {
68412	72405	switch (temp.tracking(cg).short) {
68413	72406	.none,
68414	72407	.unreach,
...	...	@@ -68451,7 +72444,7 @@ const Temp = struct {
68451	72444	}
68452	72445	}
68453	72446
68454		fn toMemory(temp: Temp, cg: CodeGen) !bool {
	72447	fn toMemory(temp: Temp, cg: CodeGen) InnerError!bool {
68455	72448	const temp_tracking = temp.tracking(cg);
68456	72449	if (temp_tracking.short.isMemory()) return false;
68457	72450	const new_temp_index = cg.next_temp_index;
...	...	@@ -68467,7 +72460,7 @@ const Temp = struct {
68467	72460	}
68468	72461
68469	72462	// hack around linker relocation bugs
68470		fn toBase(temp: Temp, cg: CodeGen) !bool {
	72463	fn toBase(temp: Temp, cg: CodeGen) InnerError!bool {
68471	72464	const temp_tracking = temp.tracking(cg);
68472	72465	if (temp_tracking.short.isBase()) return false;
68473	72466	if (try temp.toMemory(cg)) return true;
...	...	@@ -68488,7 +72481,7 @@ const Temp = struct {
68488	72481	safe: bool = false,
68489	72482	};
68490	72483
68491		fn load(ptr: Temp, val_ty: Type, opts: AccessOptions, cg: CodeGen) !Temp {
	72484	fn load(ptr: Temp, val_ty: Type, opts: AccessOptions, cg: CodeGen) InnerError!Temp {
68492	72485	const val = try cg.tempAlloc(val_ty);
68493	72486	try ptr.toOffset(opts.disp, cg);
68494	72487	while (try ptr.toLea(cg)) {}
...	...	@@ -68525,7 +72518,7 @@ const Temp = struct {
68525	72518	return val;
68526	72519	}
68527	72520
68528		fn store(ptr: Temp, val: Temp, opts: AccessOptions, cg: *CodeGen) !void {
	72521	fn store(ptr: Temp, val: Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {
68529	72522	const val_ty = val.typeOf(cg);
68530	72523	try ptr.toOffset(opts.disp, cg);
68531	72524	while (try ptr.toLea(cg)) {}
...	...	@@ -68623,10 +72616,14 @@ const Temp = struct {
68623	72616	}
68624	72617	}
68625	72618
68626		fn read(src: Temp, val_ty: Type, opts: AccessOptions, cg: CodeGen) !Temp {
	72619	fn read(src: Temp, val_ty: Type, opts: AccessOptions, cg: CodeGen) InnerError!Temp {
68627	72620	var val = try cg.tempAlloc(val_ty);
68628	72621	while (try src.toBase(cg)) {}
68629		const val_mcv = val.tracking(cg).short;
	72622	try src.readTo(val_ty, val.tracking(cg).short, opts, cg);
	72623	return val;
	72624	}
	72625
	72626	fn readTo(src: Temp, val_ty: Type, val_mcv: MCValue, opts: AccessOptions, cg: CodeGen) InnerError!void {
68630	72627	switch (val_mcv) {
68631	72628	else => \|mcv\| std.debug.panic("{s}: {}\n", .{ @src().fn_name, mcv }),
68632	72629	.register => \|val_reg\| try src.readReg(opts.disp, val_ty, registerAlias(
...	...	@@ -68658,10 +72655,9 @@ const Temp = struct {
68658	72655	try len.die(cg);
68659	72656	},
68660	72657	}
68661		return val;
68662	72658	}
68663	72659
68664		fn write(dst: Temp, val: Temp, opts: AccessOptions, cg: *CodeGen) !void {
	72660	fn write(dst: Temp, val: Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {
68665	72661	const val_ty = val.typeOf(cg);
68666	72662	while (try dst.toBase(cg)) {}
68667	72663	val_to_gpr: while (true) : (while (try dst.toBase(cg) or
...	...	@@ -68757,7 +72753,7 @@ const Temp = struct {
68757	72753	}
68758	72754	}
68759	72755
68760		fn loadReg(ptr: Temp, dst_ty: Type, dst_reg: Register, cg: CodeGen) !void {
	72756	fn loadReg(ptr: Temp, dst_ty: Type, dst_reg: Register, cg: CodeGen) InnerError!void {
68761	72757	const dst_rc = dst_reg.class();
68762	72758	const strat = try cg.moveStrategy(dst_ty, dst_rc, false);
68763	72759	// hack around linker relocation bugs
...	...	@@ -68771,7 +72767,7 @@ const Temp = struct {
68771	72767	}));
68772	72768	}
68773	72769
68774		fn storeRegs(ptr: Temp, src_ty: Type, src_regs: []const Register, cg: CodeGen) !void {
	72770	fn storeRegs(ptr: Temp, src_ty: Type, src_regs: []const Register, cg: CodeGen) InnerError!void {
68775	72771	var part_disp: u31 = 0;
68776	72772	var deferred_disp: u31 = 0;
68777	72773	var src_abi_size: u32 = @intCast(src_ty.abiSize(cg.pt.zcu));
...	...	@@ -68815,7 +72811,7 @@ const Temp = struct {
68815	72811	}
68816	72812	}
68817	72813
68818		fn readReg(src: Temp, disp: i32, dst_ty: Type, dst_reg: Register, cg: *CodeGen) !void {
	72814	fn readReg(src: Temp, disp: i32, dst_ty: Type, dst_reg: Register, cg: *CodeGen) InnerError!void {
68819	72815	const strat = try cg.moveStrategy(dst_ty, dst_reg.class(), false);
68820	72816	try strat.read(cg, dst_reg, try src.tracking(cg).short.mem(cg, .{
68821	72817	.size = .fromBitSize(@min(8 * dst_ty.abiSize(cg.pt.zcu), dst_reg.bitSize())),
...	...	@@ -68823,7 +72819,7 @@ const Temp = struct {
68823	72819	}));
68824	72820	}
68825	72821
68826		fn writeRegs(dst: Temp, disp: i32, src_ty: Type, src_regs: []const Register, cg: *CodeGen) !void {
	72822	fn writeRegs(dst: Temp, disp: i32, src_ty: Type, src_regs: []const Register, cg: *CodeGen) InnerError!void {
68827	72823	var part_disp = disp;
68828	72824	var src_abi_size: u32 = @intCast(src_ty.abiSize(cg.pt.zcu));
68829	72825	for (src_regs) \|src_reg\| {
...	...	@@ -68861,14 +72857,14 @@ const Temp = struct {
68861	72857	}
68862	72858	}
68863	72859
68864		fn memcpy(dst: Temp, src: Temp, len: Temp, cg: CodeGen) !void {
	72860	fn memcpy(dst: Temp, src: Temp, len: Temp, cg: CodeGen) InnerError!void {
68865	72861	while (true) for ([_]*Temp{ dst, src, len }, [_]Register{ .rdi, .rsi, .rcx }) \|temp, reg\| {
68866	72862	if (try temp.toReg(reg, cg)) break;
68867	72863	} else break;
68868	72864	try cg.asmOpOnly(.{ .@"rep _sb", .mov });
68869	72865	}
68870	72866
68871		fn memset(dst: Temp, val: Temp, len: Temp, cg: CodeGen) !void {
	72867	fn memset(dst: Temp, val: Temp, len: Temp, cg: CodeGen) InnerError!void {
68872	72868	while (true) for ([_]*Temp{ dst, val, len }, [_]Register{ .rdi, .rax, .rcx }) \|temp, reg\| {
68873	72869	if (try temp.toReg(reg, cg)) break;
68874	72870	} else break;
...	...	@@ -68877,7 +72873,7 @@ const Temp = struct {
68877	72873
68878	72874	/// Supports any `op` using `cg.intInfo(lhs.typeOf(cg)).?.signedness` as the signedness.
68879	72875	/// Returns `error.SelectFailed` when `cg.intInfo(lhs.typeOf(cg)) == null`.
68880		fn cmpInts(lhs: Temp, op: std.math.CompareOperator, rhs: Temp, cg: *CodeGen) !Temp {
	72876	fn cmpInts(lhs: Temp, op: std.math.CompareOperator, rhs: Temp, cg: *CodeGen) Select.Error!Temp {
68881	72877	var ops: [2]Temp = .{ lhs., rhs. };
68882	72878	var res: [1]Temp = undefined;
68883	72879	switch (op) {
...	...	@@ -69838,7 +73834,7 @@ const Temp = struct {
69838	73834	op_refs: []const Air.Inst.Ref,
69839	73835	op_temps: []const Temp,
69840	73836	cg: *CodeGen,
69841		) !void {
	73837	) InnerError!void {
69842	73838	const tomb_bits = cg.liveness.getTombBits(inst);
69843	73839	for (0.., op_refs, op_temps) \|op_index, op_ref, op_temp\| {
69844	73840	if (op_temp.index != temp.index) try op_temp.die(cg);
...	...	@@ -69862,7 +73858,7 @@ const Temp = struct {
69862	73858	}
69863	73859	}
69864	73860
69865		fn die(temp: Temp, cg: *CodeGen) !void {
	73861	fn die(temp: Temp, cg: *CodeGen) InnerError!void {
69866	73862	switch (temp.unwrap(cg)) {
69867	73863	.ref, .err_ret_trace => {},
69868	73864	.temp => \|temp_index\| try temp_index.tracking(cg).die(cg, temp_index.toIndex()),
...	...	@@ -69916,7 +73912,7 @@ const Temp = struct {
69916	73912	};
69917	73913	};
69918	73914
69919		fn resetTemps(cg: *CodeGen) !void {
	73915	fn resetTemps(cg: *CodeGen) InnerError!void {
69920	73916	var any_valid = false;
69921	73917	for (0..@intFromEnum(cg.next_temp_index)) \|temp_index\| {
69922	73918	const temp: Temp.Index = @enumFromInt(temp_index);
...	...	@@ -69962,7 +73958,7 @@ fn reuseTemp(
69962	73958	return true;
69963	73959	}
69964	73960
69965		fn tempAlloc(cg: *CodeGen, ty: Type) !Temp {
	73961	fn tempAlloc(cg: *CodeGen, ty: Type) InnerError!Temp {
69966	73962	const temp_index = cg.next_temp_index;
69967	73963	temp_index.tracking(cg).* = .init(
69968	73964	try cg.allocRegOrMemAdvanced(ty, temp_index.toIndex(), true),
...	...	@@ -69972,7 +73968,7 @@ fn tempAlloc(cg: *CodeGen, ty: Type) !Temp {
69972	73968	return .{ .index = temp_index.toIndex() };
69973	73969	}
69974	73970
69975		fn tempAllocReg(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) !Temp {
	73971	fn tempAllocReg(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) InnerError!Temp {
69976	73972	const temp_index = cg.next_temp_index;
69977	73973	temp_index.tracking(cg).* = .init(
69978	73974	.{ .register = try cg.register_manager.allocReg(temp_index.toIndex(), rs) },
...	...	@@ -69982,7 +73978,7 @@ fn tempAllocReg(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) !Tem
69982	73978	return .{ .index = temp_index.toIndex() };
69983	73979	}
69984	73980
69985		fn tempAllocRegPair(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) !Temp {
	73981	fn tempAllocRegPair(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) InnerError!Temp {
69986	73982	const temp_index = cg.next_temp_index;
69987	73983	temp_index.tracking(cg).* = .init(
69988	73984	.{ .register_pair = try cg.register_manager.allocRegs(2, temp_index.toIndex(), rs) },
...	...	@@ -69992,7 +73988,7 @@ fn tempAllocRegPair(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet)
69992	73988	return .{ .index = temp_index.toIndex() };
69993	73989	}
69994	73990
69995		fn tempAllocMem(cg: *CodeGen, ty: Type) !Temp {
	73991	fn tempAllocMem(cg: *CodeGen, ty: Type) InnerError!Temp {
69996	73992	const temp_index = cg.next_temp_index;
69997	73993	temp_index.tracking(cg).* = .init(
69998	73994	try cg.allocRegOrMemAdvanced(ty, temp_index.toIndex(), false),
...	...	@@ -70002,7 +73998,7 @@ fn tempAllocMem(cg: *CodeGen, ty: Type) !Temp {
70002	73998	return .{ .index = temp_index.toIndex() };
70003	73999	}
70004	74000
70005		fn tempInit(cg: *CodeGen, ty: Type, value: MCValue) !Temp {
	74001	fn tempInit(cg: *CodeGen, ty: Type, value: MCValue) InnerError!Temp {
70006	74002	const temp_index = cg.next_temp_index;
70007	74003	temp_index.tracking(cg).* = .init(value);
70008	74004	cg.temp_type[@intFromEnum(temp_index)] = ty;
...	...	@@ -70011,11 +74007,11 @@ fn tempInit(cg: *CodeGen, ty: Type, value: MCValue) !Temp {
70011	74007	return .{ .index = temp_index.toIndex() };
70012	74008	}
70013	74009
70014		fn tempFromValue(cg: *CodeGen, value: Value) !Temp {
	74010	fn tempFromValue(cg: *CodeGen, value: Value) InnerError!Temp {
70015	74011	return cg.tempInit(value.typeOf(cg.pt.zcu), try cg.genTypedValue(value));
70016	74012	}
70017	74013
70018		fn tempMemFromValue(cg: *CodeGen, value: Value) !Temp {
	74014	fn tempMemFromValue(cg: *CodeGen, value: Value) InnerError!Temp {
70019	74015	return cg.tempInit(value.typeOf(cg.pt.zcu), try cg.lowerUav(value));
70020	74016	}
70021	74017
...	...	@@ -70025,7 +74021,7 @@ fn tempFromOperand(
70025	74021	op_index: Liveness.OperandInt,
70026	74022	op_ref: Air.Inst.Ref,
70027	74023	ignore_death: bool,
70028		) !Temp {
	74024	) InnerError!Temp {
70029	74025	const zcu = cg.pt.zcu;
70030	74026	const ip = &zcu.intern_pool;
70031	74027
...	...	@@ -70075,7 +74071,7 @@ fn tempFromOperand(
70075	74071	return temp;
70076	74072	}
70077	74073
70078		inline fn tempsFromOperands(cg: *CodeGen, inst: Air.Inst.Index, op_refs: anytype) ![op_refs.len]Temp {
	74074	inline fn tempsFromOperands(cg: *CodeGen, inst: Air.Inst.Index, op_refs: anytype) InnerError![op_refs.len]Temp {
70079	74075	var temps: [op_refs.len]Temp = undefined;
70080	74076	inline for (&temps, 0.., op_refs) \|*temp, op_index, op_ref\| {
70081	74077	temp.* = try cg.tempFromOperand(inst, op_index, op_ref, inline for (0..op_index) \|prev_op_index\| {
...	...	@@ -70103,6 +74099,8 @@ const Select = struct {
70103	74099	},
70104	74100	top: u3,
70105	74101
	74102	const Error = InnerError \|\| error{SelectFailed};
	74103
70106	74104	fn emitLabel(s: *Select, label_index: Label) void {
70107	74105	assert(@intFromEnum(label_index) < @intFromEnum(Label._));
70108	74106	const label = &s.labels[@intFromEnum(label_index)];
...	...	@@ -70113,7 +74111,7 @@ const Select = struct {
70113	74111	label.backward = @intCast(s.cg.mir_instructions.len);
70114	74112	}
70115	74113
70116		fn emit(s: *Select, inst: Instruction) !void {
	74114	fn emit(s: *Select, inst: Instruction) InnerError!void {
70117	74115	const mir_tag: Mir.Inst.FixedTag = .{ inst[1], inst[2] };
70118	74116	pseudo: {
70119	74117	switch (inst[0]) {
...	...	@@ -70236,7 +74234,7 @@ const Select = struct {
70236	74234	else => unreachable,
70237	74235	},
70238	74236	.fi_p => switch (mir_tag[1]) {
70239		.com, .st => s.top +%= 1,
	74237	.com, .st, .stt => s.top +%= 1,
70240	74238	else => unreachable,
70241	74239	},
70242	74240	.fn_ => switch (mir_tag[1]) {
...	...	@@ -70326,6 +74324,7 @@ const Select = struct {
70326	74324	exact_unsigned_int: u16,
70327	74325	signed_or_exact_int: Memory.Size,
70328	74326	unsigned_or_exact_int: Memory.Size,
	74327	signed_or_exclusive_int: Memory.Size,
70329	74328	po2_int: Memory.Size,
70330	74329	signed_po2_int: Memory.Size,
70331	74330	unsigned_po2_or_exact_int: Memory.Size,
...	...	@@ -70452,6 +74451,10 @@ const Select = struct {
70452	74451	.signed => size.bitSize(cg.target) == int_info.bits,
70453	74452	.unsigned => size.bitSize(cg.target) >= int_info.bits,
70454	74453	} else false,
	74454	.signed_or_exclusive_int => \|size\| if (cg.intInfo(ty)) \|int_info\| switch (int_info.signedness) {
	74455	.signed => size.bitSize(cg.target) >= int_info.bits,
	74456	.unsigned => size.bitSize(cg.target) > int_info.bits,
	74457	} else false,
70455	74458	.po2_int => \|size\| if (cg.intInfo(ty)) \|int_info\|
70456	74459	std.math.isPowerOfTwo(int_info.bits) and size.bitSize(cg.target) >= int_info.bits
70457	74460	else
...	...	@@ -70512,12 +74515,12 @@ const Select = struct {
70512	74515
70513	74516	const Src = union(enum) {
70514	74517	none,
70515		any,
70516	74518	imm8,
70517	74519	imm16,
70518	74520	imm32,
70519	74521	simm32,
70520	74522	to_reg: Register,
	74523	to_reg_pair: [2]Register,
70521	74524	mem,
70522	74525	to_mem,
70523	74526	mut_mem,
...	...	@@ -70554,7 +74557,6 @@ const Select = struct {
70554	74557	fn matches(src: Src, temp: Temp, cg: *CodeGen) bool {
70555	74558	return switch (src) {
70556	74559	.none => unreachable,
70557		.any => true,
70558	74560	.imm8 => switch (temp.tracking(cg).short) {
70559	74561	.immediate => \|imm\| std.math.cast(u8, imm) != null,
70560	74562	else => false,
...	...	@@ -70574,7 +74576,7 @@ const Select = struct {
70574	74576	.mem => temp.tracking(cg).short.isMemory(),
70575	74577	.to_mem, .to_mut_mem => true,
70576	74578	.mut_mem => temp.isMut(cg) and temp.tracking(cg).short.isMemory(),
70577		.to_reg => true,
	74579	.to_reg, .to_reg_pair => true,
70578	74580	.gpr => temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) {
70579	74581	.register => \|reg\| reg.class() == .general_purpose,
70580	74582	.register_offset => \|reg_off\| reg_off.reg.class() == .general_purpose and reg_off.off == 0,
...	...	@@ -70655,12 +74657,13 @@ const Select = struct {
70655	74657	};
70656	74658	}
70657	74659
70658		fn convert(src: Src, temp: Temp, cg: CodeGen) !bool {
	74660	fn convert(src: Src, temp: Temp, cg: CodeGen) InnerError!bool {
70659	74661	return switch (src) {
70660	74662	.none => unreachable,
70661		.any, .imm8, .imm16, .imm32, .simm32 => false,
	74663	.imm8, .imm16, .imm32, .simm32 => false,
70662	74664	.mem, .to_mem, .mut_mem, .to_mut_mem => try temp.toBase(cg),
70663	74665	.to_reg => \|reg\| try temp.toReg(reg, cg),
	74666	.to_reg_pair => \|regs\| try temp.toRegPair(regs, cg),
70664	74667	.gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg),
70665	74668	.mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg),
70666	74669	.x87, .to_x87 => try temp.toRegClass(false, .x87, cg),
...	...	@@ -70686,6 +74689,7 @@ const Select = struct {
70686	74689	cc: Condition,
70687	74690	ref: Select.Operand.Ref,
70688	74691	reg: Register,
	74692	reg_pair: [2]Register,
70689	74693	rc: Register.Class,
70690	74694	mut_rc: struct { ref: Select.Operand.Ref, rc: Register.Class },
70691	74695	ref_mask: struct { ref: Select.Operand.Ref, info: MaskInfo },
...	...	@@ -70696,11 +74700,15 @@ const Select = struct {
70696	74700	smax_mem: ConstInfo,
70697	74701	umin_mem: ConstInfo,
70698	74702	umax_mem: ConstInfo,
	74703	@"0x1p63_mem": ConstInfo,
	74704	f64_0x1p52_0x1p84_mem,
	74705	u32_0x1p52_hi_0x1p84_hi_0_0_mem,
	74706	f32_0_0x1p64_mem,
70699	74707	frame: FrameIndex,
70700	74708	symbol: *const struct { lib: ?[]const u8 = null, name: []const u8 },
70701	74709
70702	74710	const ConstInfo = struct {
70703		ref: Select.Operand.Ref,
	74711	ref: ?Select.Operand.Ref = null,
70704	74712	to_signedness: ?std.builtin.Signedness = null,
70705	74713	vectorize_to: ?Memory.Size = null,
70706	74714	};
...	...	@@ -70721,14 +74729,16 @@ const Select = struct {
70721	74729	}
70722	74730	};
70723	74731
70724		fn create(spec: TempSpec, s: *Select) !struct { Temp, bool } {
	74732	fn create(spec: TempSpec, s: *Select) InnerError!struct { Temp, bool } {
70725	74733	const cg = s.cg;
	74734	const pt = cg.pt;
70726	74735	return switch (spec.kind) {
70727	74736	.unused => unreachable,
70728	74737	.any => .{ try cg.tempAlloc(spec.type), true },
70729	74738	.cc => \|cc\| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true },
70730	74739	.ref => \|ref\| .{ ref.tempOf(s), false },
70731	74740	.reg => \|reg\| .{ try cg.tempInit(spec.type, .{ .register = reg }), true },
	74741	.reg_pair => \|regs\| .{ try cg.tempInit(spec.type, .{ .register_pair = regs }), true },
70732	74742	.rc => \|rc\| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true },
70733	74743	.mut_rc => \|ref_rc\| {
70734	74744	const temp = ref_rc.ref.tempOf(s);
...	...	@@ -70751,11 +74761,10 @@ const Select = struct {
70751	74761	return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true };
70752	74762	},
70753	74763	.mem => .{ try cg.tempAllocMem(spec.type), true },
70754		.smin_mem, .smax_mem, .umin_mem, .umax_mem => \|const_info\| {
70755		const pt = cg.pt;
	74764	.smin_mem, .smax_mem, .umin_mem, .umax_mem, .@"0x1p63_mem" => \|const_info\| {
70756	74765	const zcu = pt.zcu;
70757	74766	const ip = &zcu.intern_pool;
70758		const ty = const_info.ref.typeOf(s);
	74767	const ty = if (const_info.ref) \|ref\| ref.typeOf(s) else spec.type;
70759	74768	const vector_len, const scalar_ty: Type = switch (ip.indexToKey(ty.toIntern())) {
70760	74769	else => .{ null, ty },
70761	74770	.vector_type => \|vector_type\| .{ vector_type.len, .fromInterned(vector_type.child) },
...	...	@@ -70780,6 +74789,7 @@ const Select = struct {
70780	74789	};
70781	74790	const scalar_signedness = const_info.to_signedness orelse scalar_info.signedness;
70782	74791	const scalar_int_ty = try pt.intType(scalar_signedness, scalar_info.bits);
	74792
70783	74793	if (scalar_info.bits <= 64) {
70784	74794	const int_val: i64 = switch (spec.kind) {
70785	74795	else => unreachable,
...	...	@@ -70787,6 +74797,12 @@ const Select = struct {
70787	74797	.smax_mem => std.math.maxInt(i64),
70788	74798	.umin_mem => 0,
70789	74799	.umax_mem => -1,
	74800	.@"0x1p63_mem" => switch (scalar_info.bits) {
	74801	else => unreachable,
	74802	16 => @as(i64, @as(i16, @bitCast(@as(f16, 0x1p63)))) << 64 - 16,
	74803	32 => @as(i64, @as(i32, @bitCast(@as(f32, 0x1p63)))) << 64 - 32,
	74804	64 => @as(i64, @as(i64, @bitCast(@as(f64, 0x1p63)))) << 64 - 64,
	74805	},
70790	74806	};
70791	74807	const shift: u6 = @intCast(64 - scalar_info.bits);
70792	74808	break :res_scalar .{ scalar_int_ty, switch (scalar_signedness) {
...	...	@@ -70794,18 +74810,38 @@ const Select = struct {
70794	74810	.unsigned => try pt.intValue_u64(scalar_int_ty, @as(u64, @bitCast(int_val)) >> shift),
70795	74811	} };
70796	74812	}
70797		var big_int: std.math.big.int.Managed = try .init(cg.gpa);
70798		defer big_int.deinit();
70799		try big_int.setTwosCompIntLimit(switch (spec.kind) {
70800		else => unreachable,
70801		.smin_mem, .umin_mem => .min,
70802		.smax_mem, .umax_mem => .max,
70803		}, switch (spec.kind) {
	74813
	74814	const ExpectedContents = [std.math.big.int.calcTwosCompLimbCount(1 << 10)]std.math.big.Limb;
	74815	var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) =
	74816	std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa);
	74817	const allocator = stack.get();
	74818	var big_int: std.math.big.int.Mutable = .{
	74819	.limbs = try allocator.alloc(
	74820	std.math.big.Limb,
	74821	std.math.big.int.calcTwosCompLimbCount(scalar_info.bits),
	74822	),
	74823	.len = undefined,
	74824	.positive = undefined,
	74825	};
	74826	defer allocator.free(big_int.limbs);
	74827	switch (spec.kind) {
70804	74828	else => unreachable,
70805		.smin_mem, .smax_mem => .signed,
70806		.umin_mem, .umax_mem => .unsigned,
70807		}, scalar_info.bits);
70808		try big_int.truncate(&big_int, scalar_signedness, scalar_info.bits);
	74829	.smin_mem, .smax_mem, .umin_mem, .umax_mem => big_int.setTwosCompIntLimit(switch (spec.kind) {
	74830	else => unreachable,
	74831	.smin_mem, .umin_mem => .min,
	74832	.smax_mem, .umax_mem => .max,
	74833	}, switch (spec.kind) {
	74834	else => unreachable,
	74835	.smin_mem, .smax_mem => .signed,
	74836	.umin_mem, .umax_mem => .unsigned,
	74837	}, scalar_info.bits),
	74838	.@"0x1p63_mem" => switch (scalar_info.bits) {
	74839	else => unreachable,
	74840	80 => big_int.set(@as(u80, @bitCast(@as(f80, 0x1p63)))),
	74841	128 => big_int.set(@as(u128, @bitCast(@as(f128, 0x1p63)))),
	74842	},
	74843	}
	74844	big_int.truncate(big_int.toConst(), scalar_signedness, scalar_info.bits);
70809	74845	break :res_scalar .{ scalar_int_ty, try pt.intValue_big(scalar_int_ty, big_int.toConst()) };
70810	74846	},
70811	74847	};
...	...	@@ -70818,6 +74854,27 @@ const Select = struct {
70818	74854	} })) else res_scalar_val;
70819	74855	return .{ try cg.tempMemFromValue(res_val), true };
70820	74856	},
	74857	.f64_0x1p52_0x1p84_mem => .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
	74858	.ty = (try pt.vectorType(.{ .len = 2, .child = .f64_type })).toIntern(),
	74859	.storage = .{ .elems = &.{
	74860	(try pt.floatValue(.f64, @as(f64, 0x1p52))).toIntern(),
	74861	(try pt.floatValue(.f64, @as(f64, 0x1p84))).toIntern(),
	74862	} },
	74863	} }))), true },
	74864	.u32_0x1p52_hi_0x1p84_hi_0_0_mem => .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
	74865	.ty = (try pt.vectorType(.{ .len = 4, .child = .u32_type })).toIntern(),
	74866	.storage = .{ .elems = &(.{
	74867	(try pt.intValue(.u32, @as(u64, @bitCast(@as(f64, 0x1p52))) >> 32)).toIntern(),
	74868	(try pt.intValue(.u32, @as(u64, @bitCast(@as(f64, 0x1p84))) >> 32)).toIntern(),
	74869	} ++ .{(try pt.intValue(.u32, 0)).toIntern()} ** 2) },
	74870	} }))), true },
	74871	.f32_0_0x1p64_mem => .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
	74872	.ty = (try pt.vectorType(.{ .len = 2, .child = .f32_type })).toIntern(),
	74873	.storage = .{ .elems = &.{
	74874	(try pt.floatValue(.f32, @as(f32, 0))).toIntern(),
	74875	(try pt.floatValue(.f32, @as(f32, 0x1p64))).toIntern(),
	74876	} },
	74877	} }))), true },
70821	74878	.frame => \|frame_index\| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true },
70822	74879	.symbol => \|symbol\| .{ try cg.tempInit(spec.type, .{ .lea_symbol = .{
70823	74880	.sym_index = if (cg.bin_file.cast(.elf)) \|elf_file\|
...	...	@@ -70893,6 +74950,7 @@ const Select = struct {
70893	74950	const none: Adjust = .{ .sign = .pos, .lhs = .none, .op = .mul, .rhs = .@"1" };
70894	74951	const sub_ptr_size: Adjust = .{ .sign = .neg, .lhs = .ptr_size, .op = .mul, .rhs = .@"1" };
70895	74952	const add_ptr_bit_size: Adjust = .{ .sign = .pos, .lhs = .ptr_bit_size, .op = .mul, .rhs = .@"1" };
	74953	const add_8_size: Adjust = .{ .sign = .pos, .lhs = .size, .op = .mul, .rhs = .@"8" };
70896	74954	const add_size: Adjust = .{ .sign = .pos, .lhs = .size, .op = .mul, .rhs = .@"1" };
70897	74955	const add_size_div_4: Adjust = .{ .sign = .pos, .lhs = .size, .op = .div, .rhs = .@"4" };
70898	74956	const add_size_div_8: Adjust = .{ .sign = .pos, .lhs = .size, .op = .div, .rhs = .@"8" };
...	...	@@ -71493,7 +75551,7 @@ const Select = struct {
71493	75551	};
71494	75552	}
71495	75553
71496		fn lower(op: Select.Operand, s: *Select) !CodeGen.Operand {
	75554	fn lower(op: Select.Operand, s: *Select) InnerError!CodeGen.Operand {
71497	75555	return switch (op.flags.tag) {
71498	75556	.none => .none,
71499	75557	.backward_label => .{ .inst = s.labels[@intFromEnum(op.base.ref)].backward.? },
...	...	@@ -71547,7 +75605,7 @@ fn select(
71547	75605	dst_tys: []const Type,
71548	75606	src_temps: []Temp,
71549	75607	cases: []const Select.Case,
71550		) !void {
	75608	) Select.Error!void {
71551	75609	@setEvalBranchQuota(33_500);
71552	75610	cases: for (cases) \|case\| {
71553	75611	for (case.required_features) \|required_feature\| if (required_feature) \|feature\| if (!cg.hasFeature(feature)) continue :cases;

src/arch/x86_64/Encoding.zig+3-3

...	...	@@ -379,7 +379,7 @@ pub const Mnemonic = enum {
379	379	sqrtps, sqrtss,
380	380	stmxcsr,
381	381	subps, subss,
382		ucomiss,
	382	ucomiss, unpckhps, unpcklps,
383	383	xorps,
384	384	// SSE2
385	385	addpd, addsd,
...	...	@@ -409,7 +409,7 @@ pub const Mnemonic = enum {
409	409	shufpd,
410	410	sqrtpd, sqrtsd,
411	411	subpd, subsd,
412		ucomisd,
	412	ucomisd, unpckhpd, unpcklpd,
413	413	xorpd,
414	414	// SSE3
415	415	addsubpd, addsubps, haddpd, haddps, lddqu, movddup, movshdup, movsldup,
...	...	@@ -504,7 +504,7 @@ pub const Mnemonic = enum {
504	504	vstmxcsr,
505	505	vsubpd, vsubps, vsubsd, vsubss,
506	506	vtestpd, vtestps,
507		vucomisd, vucomiss,
	507	vucomisd, vucomiss, vunpckhpd, vunpckhps, vunpcklpd, vunpcklps,
508	508	vxorpd, vxorps,
509	509	// F16C
510	510	vcvtph2ps, vcvtps2ph,

src/arch/x86_64/encodings.zig+20

...	...	@@ -1392,6 +1392,10 @@ pub const table = [_]Entry{
1392	1392
1393	1393	.{ .ucomiss, .rm, &.{ .xmm, .xmm_m32 }, &.{ 0x0f, 0x2e }, 0, .none, .sse },
1394	1394
	1395	.{ .unpckhps, .rm, &.{ .xmm, .xmm_m128 }, &.{ 0x0f, 0x15 }, 0, .none, .sse },
	1396
	1397	.{ .unpcklps, .rm, &.{ .xmm, .xmm_m128 }, &.{ 0x0f, 0x14 }, 0, .none, .sse },
	1398
1395	1399	.{ .xorps, .rm, &.{ .xmm, .xmm_m128 }, &.{ 0x0f, 0x57 }, 0, .none, .sse },
1396	1400
1397	1401	// SSE2
...	...	@@ -1611,6 +1615,10 @@ pub const table = [_]Entry{
1611	1615
1612	1616	.{ .ucomisd, .rm, &.{ .xmm, .xmm_m64 }, &.{ 0x66, 0x0f, 0x2e }, 0, .none, .sse2 },
1613	1617
	1618	.{ .unpckhpd, .rm, &.{ .xmm, .xmm_m128 }, &.{ 0x66, 0x0f, 0x15 }, 0, .none, .sse2 },
	1619
	1620	.{ .unpcklpd, .rm, &.{ .xmm, .xmm_m128 }, &.{ 0x66, 0x0f, 0x14 }, 0, .none, .sse2 },
	1621
1614	1622	.{ .xorpd, .rm, &.{ .xmm, .xmm_m128 }, &.{ 0x66, 0x0f, 0x57 }, 0, .none, .sse2 },
1615	1623
1616	1624	// SSE3
...	...	@@ -2281,6 +2289,18 @@ pub const table = [_]Entry{
2281	2289
2282	2290	.{ .vucomiss, .rm, &.{ .xmm, .xmm_m32 }, &.{ 0x0f, 0x2e }, 0, .vex_lig_wig, .avx },
2283	2291
	2292	.{ .vunpckhpd, .rvm, &.{ .xmm, .xmm, .xmm_m128 }, &.{ 0x66, 0x0f, 0x15 }, 0, .vex_128_wig, .avx },
	2293	.{ .vunpckhpd, .rvm, &.{ .ymm, .ymm, .ymm_m256 }, &.{ 0x66, 0x0f, 0x15 }, 0, .vex_256_wig, .avx },
	2294
	2295	.{ .vunpckhps, .rvm, &.{ .xmm, .xmm, .xmm_m128 }, &.{ 0x0f, 0x15 }, 0, .vex_128_wig, .avx },
	2296	.{ .vunpckhps, .rvm, &.{ .ymm, .ymm, .ymm_m256 }, &.{ 0x0f, 0x15 }, 0, .vex_256_wig, .avx },
	2297
	2298	.{ .vunpcklpd, .rvm, &.{ .xmm, .xmm, .xmm_m128 }, &.{ 0x66, 0x0f, 0x14 }, 0, .vex_128_wig, .avx },
	2299	.{ .vunpcklpd, .rvm, &.{ .ymm, .ymm, .ymm_m256 }, &.{ 0x66, 0x0f, 0x14 }, 0, .vex_256_wig, .avx },
	2300
	2301	.{ .vunpcklps, .rvm, &.{ .xmm, .xmm, .xmm_m128 }, &.{ 0x0f, 0x14 }, 0, .vex_128_wig, .avx },
	2302	.{ .vunpcklps, .rvm, &.{ .ymm, .ymm, .ymm_m256 }, &.{ 0x0f, 0x14 }, 0, .vex_256_wig, .avx },
	2303
2284	2304	.{ .vxorpd, .rvm, &.{ .xmm, .xmm, .xmm_m128 }, &.{ 0x66, 0x0f, 0x57 }, 0, .vex_128_wig, .avx },
2285	2305	.{ .vxorpd, .rvm, &.{ .ymm, .ymm, .ymm_m256 }, &.{ 0x66, 0x0f, 0x57 }, 0, .vex_256_wig, .avx },
2286	2306

test/behavior/x86_64/math.zig+2271

...	...	@@ -3,7 +3,10 @@ const inf = math.inf;
3	3	const math = std.math;
4	4	const fmax = math.floatMax;
5	5	const fmin = math.floatMin;
	6	const imax = math.maxInt;
	7	const imin = math.minInt;
6	8	const nan = math.nan;
	9	const next = math.nextAfter;
7	10	const std = @import("std");
8	11	const tmin = math.floatTrueMin;
9	12
...	...	@@ -8547,6 +8550,2258 @@ fn cast(comptime op: anytype, comptime opts: struct { compare: Compare = .relaxe
8547	8550	1e3, -1e-3, -fmin(f128), -inf(f128), 1e-3, tmin(f128), fmin(f128), 1e1, 1e-4, -fmax(f128), -1e2, 1e-2, -1e-2, 1e3, inf(f128), -fmin(f128),
8548	8551	});
8549	8552	}
	8553	fn testIntsFromFloats() !void {
	8554	@setEvalBranchQuota(2_600);
	8555
	8556	try testArgs(i8, f16, -0x0.8p8);
	8557	try testArgs(i8, f16, next(f16, -0x0.8p8, -0.0));
	8558	try testArgs(i8, f16, next(f16, next(f16, -0x0.8p8, -0.0), -0.0));
	8559	try testArgs(i8, f16, -1e2);
	8560	try testArgs(i8, f16, -1e1);
	8561	try testArgs(i8, f16, -1e0);
	8562	try testArgs(i8, f16, -1e-1);
	8563	try testArgs(i8, f16, -0.0);
	8564	try testArgs(i8, f16, 0.0);
	8565	try testArgs(i8, f16, 1e-1);
	8566	try testArgs(i8, f16, 1e0);
	8567	try testArgs(i8, f16, 1e1);
	8568	try testArgs(i8, f16, 1e2);
	8569	try testArgs(i8, f16, next(f16, next(f16, 0x0.8p8, 0.0), 0.0));
	8570	try testArgs(i8, f16, next(f16, 0x0.8p8, 0.0));
	8571
	8572	try testArgs(u8, f16, -0.0);
	8573	try testArgs(u8, f16, 0.0);
	8574	try testArgs(u8, f16, 1e-1);
	8575	try testArgs(u8, f16, 1e0);
	8576	try testArgs(u8, f16, 1e1);
	8577	try testArgs(u8, f16, 1e2);
	8578	try testArgs(u8, f16, next(f16, next(f16, 0x1p8, 0.0), 0.0));
	8579	try testArgs(u8, f16, next(f16, 0x1p8, 0.0));
	8580
	8581	try testArgs(i16, f16, -1e4);
	8582	try testArgs(i16, f16, -1e3);
	8583	try testArgs(i16, f16, -1e2);
	8584	try testArgs(i16, f16, -1e1);
	8585	try testArgs(i16, f16, -1e0);
	8586	try testArgs(i16, f16, -1e-1);
	8587	try testArgs(i16, f16, -0.0);
	8588	try testArgs(i16, f16, 0.0);
	8589	try testArgs(i16, f16, 1e-1);
	8590	try testArgs(i16, f16, 1e0);
	8591	try testArgs(i16, f16, 1e1);
	8592	try testArgs(i16, f16, 1e2);
	8593	try testArgs(i16, f16, 1e3);
	8594	try testArgs(i16, f16, 1e4);
	8595	try testArgs(i16, f16, next(f16, next(f16, 0x0.8p16, 0.0), 0.0));
	8596	try testArgs(i16, f16, next(f16, 0x0.8p16, 0.0));
	8597
	8598	try testArgs(u16, f16, -0.0);
	8599	try testArgs(u16, f16, 0.0);
	8600	try testArgs(u16, f16, 1e-1);
	8601	try testArgs(u16, f16, 1e0);
	8602	try testArgs(u16, f16, 1e1);
	8603	try testArgs(u16, f16, 1e2);
	8604	try testArgs(u16, f16, 1e3);
	8605	try testArgs(u16, f16, 1e4);
	8606	try testArgs(u16, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8607	try testArgs(u16, f16, next(f16, fmax(f16), 0.0));
	8608	try testArgs(u16, f16, fmax(f16));
	8609
	8610	try testArgs(i32, f16, -fmax(f16));
	8611	try testArgs(i32, f16, next(f16, -fmax(f16), -0.0));
	8612	try testArgs(i32, f16, next(f16, next(f16, -fmax(f16), -0.0), -0.0));
	8613	try testArgs(i32, f16, -1e4);
	8614	try testArgs(i32, f16, -1e3);
	8615	try testArgs(i32, f16, -1e2);
	8616	try testArgs(i32, f16, -1e1);
	8617	try testArgs(i32, f16, -1e0);
	8618	try testArgs(i32, f16, -1e-1);
	8619	try testArgs(i32, f16, -0.0);
	8620	try testArgs(i32, f16, 0.0);
	8621	try testArgs(i32, f16, 1e-1);
	8622	try testArgs(i32, f16, 1e0);
	8623	try testArgs(i32, f16, 1e1);
	8624	try testArgs(i32, f16, 1e2);
	8625	try testArgs(i32, f16, 1e3);
	8626	try testArgs(i32, f16, 1e4);
	8627	try testArgs(i32, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8628	try testArgs(i32, f16, next(f16, fmax(f16), 0.0));
	8629	try testArgs(i32, f16, fmax(f16));
	8630
	8631	try testArgs(u32, f16, -0.0);
	8632	try testArgs(u32, f16, 0.0);
	8633	try testArgs(u32, f16, 1e-1);
	8634	try testArgs(u32, f16, 1e0);
	8635	try testArgs(u32, f16, 1e1);
	8636	try testArgs(u32, f16, 1e2);
	8637	try testArgs(u32, f16, 1e3);
	8638	try testArgs(u32, f16, 1e4);
	8639	try testArgs(u32, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8640	try testArgs(u32, f16, next(f16, fmax(f16), 0.0));
	8641	try testArgs(u32, f16, fmax(f16));
	8642
	8643	try testArgs(i64, f16, -fmax(f16));
	8644	try testArgs(i64, f16, next(f16, -fmax(f16), -0.0));
	8645	try testArgs(i64, f16, next(f16, next(f16, -fmax(f16), -0.0), -0.0));
	8646	try testArgs(i64, f16, -1e4);
	8647	try testArgs(i64, f16, -1e3);
	8648	try testArgs(i64, f16, -1e2);
	8649	try testArgs(i64, f16, -1e1);
	8650	try testArgs(i64, f16, -1e0);
	8651	try testArgs(i64, f16, -1e-1);
	8652	try testArgs(i64, f16, -0.0);
	8653	try testArgs(i64, f16, 0.0);
	8654	try testArgs(i64, f16, 1e-1);
	8655	try testArgs(i64, f16, 1e0);
	8656	try testArgs(i64, f16, 1e1);
	8657	try testArgs(i64, f16, 1e2);
	8658	try testArgs(i64, f16, 1e3);
	8659	try testArgs(i64, f16, 1e4);
	8660	try testArgs(i64, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8661	try testArgs(i64, f16, next(f16, fmax(f16), 0.0));
	8662	try testArgs(i64, f16, fmax(f16));
	8663
	8664	try testArgs(u64, f16, -0.0);
	8665	try testArgs(u64, f16, 0.0);
	8666	try testArgs(u64, f16, 1e-1);
	8667	try testArgs(u64, f16, 1e0);
	8668	try testArgs(u64, f16, 1e1);
	8669	try testArgs(u64, f16, 1e2);
	8670	try testArgs(u64, f16, 1e3);
	8671	try testArgs(u64, f16, 1e4);
	8672	try testArgs(u64, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8673	try testArgs(u64, f16, next(f16, fmax(f16), 0.0));
	8674	try testArgs(u64, f16, fmax(f16));
	8675
	8676	try testArgs(i128, f16, -fmax(f16));
	8677	try testArgs(i128, f16, next(f16, -fmax(f16), -0.0));
	8678	try testArgs(i128, f16, next(f16, next(f16, -fmax(f16), -0.0), -0.0));
	8679	try testArgs(i128, f16, -1e4);
	8680	try testArgs(i128, f16, -1e3);
	8681	try testArgs(i128, f16, -1e2);
	8682	try testArgs(i128, f16, -1e1);
	8683	try testArgs(i128, f16, -1e0);
	8684	try testArgs(i128, f16, -1e-1);
	8685	try testArgs(i128, f16, -0.0);
	8686	try testArgs(i128, f16, 0.0);
	8687	try testArgs(i128, f16, 1e-1);
	8688	try testArgs(i128, f16, 1e0);
	8689	try testArgs(i128, f16, 1e1);
	8690	try testArgs(i128, f16, 1e2);
	8691	try testArgs(i128, f16, 1e3);
	8692	try testArgs(i128, f16, 1e4);
	8693	try testArgs(i128, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8694	try testArgs(i128, f16, next(f16, fmax(f16), 0.0));
	8695	try testArgs(i128, f16, fmax(f16));
	8696
	8697	try testArgs(u128, f16, -0.0);
	8698	try testArgs(u128, f16, 0.0);
	8699	try testArgs(u128, f16, 1e-1);
	8700	try testArgs(u128, f16, 1e0);
	8701	try testArgs(u128, f16, 1e1);
	8702	try testArgs(u128, f16, 1e2);
	8703	try testArgs(u128, f16, 1e3);
	8704	try testArgs(u128, f16, 1e4);
	8705	try testArgs(u128, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8706	try testArgs(u128, f16, next(f16, fmax(f16), 0.0));
	8707	try testArgs(u128, f16, fmax(f16));
	8708
	8709	try testArgs(i256, f16, -fmax(f16));
	8710	try testArgs(i256, f16, next(f16, -fmax(f16), -0.0));
	8711	try testArgs(i256, f16, next(f16, next(f16, -fmax(f16), -0.0), -0.0));
	8712	try testArgs(i256, f16, -1e4);
	8713	try testArgs(i256, f16, -1e3);
	8714	try testArgs(i256, f16, -1e2);
	8715	try testArgs(i256, f16, -1e1);
	8716	try testArgs(i256, f16, -1e0);
	8717	try testArgs(i256, f16, -1e-1);
	8718	try testArgs(i256, f16, -0.0);
	8719	try testArgs(i256, f16, 0.0);
	8720	try testArgs(i256, f16, 1e-1);
	8721	try testArgs(i256, f16, 1e0);
	8722	try testArgs(i256, f16, 1e1);
	8723	try testArgs(i256, f16, 1e2);
	8724	try testArgs(i256, f16, 1e3);
	8725	try testArgs(i256, f16, 1e4);
	8726	try testArgs(i256, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8727	try testArgs(i256, f16, next(f16, fmax(f16), 0.0));
	8728	try testArgs(i256, f16, fmax(f16));
	8729
	8730	try testArgs(u256, f16, -0.0);
	8731	try testArgs(u256, f16, 0.0);
	8732	try testArgs(u256, f16, 1e-1);
	8733	try testArgs(u256, f16, 1e0);
	8734	try testArgs(u256, f16, 1e1);
	8735	try testArgs(u256, f16, 1e2);
	8736	try testArgs(u256, f16, 1e3);
	8737	try testArgs(u256, f16, 1e4);
	8738	try testArgs(u256, f16, next(f16, next(f16, fmax(f16), 0.0), 0.0));
	8739	try testArgs(u256, f16, next(f16, fmax(f16), 0.0));
	8740	try testArgs(u256, f16, fmax(f16));
	8741
	8742	try testArgs(i8, f32, -0x0.8p8);
	8743	try testArgs(i8, f32, next(f32, -0x0.8p8, -0.0));
	8744	try testArgs(i8, f32, next(f32, next(f32, -0x0.8p8, -0.0), -0.0));
	8745	try testArgs(i8, f32, -1e2);
	8746	try testArgs(i8, f32, -1e1);
	8747	try testArgs(i8, f32, -1e0);
	8748	try testArgs(i8, f32, -1e-1);
	8749	try testArgs(i8, f32, -0.0);
	8750	try testArgs(i8, f32, 0.0);
	8751	try testArgs(i8, f32, 1e-1);
	8752	try testArgs(i8, f32, 1e0);
	8753	try testArgs(i8, f32, 1e1);
	8754	try testArgs(i8, f32, 1e2);
	8755	try testArgs(i8, f32, next(f32, next(f32, 0x0.8p8, 0.0), 0.0));
	8756	try testArgs(i8, f32, next(f32, 0x0.8p8, 0.0));
	8757
	8758	try testArgs(u8, f32, -0.0);
	8759	try testArgs(u8, f32, 0.0);
	8760	try testArgs(u8, f32, 1e-1);
	8761	try testArgs(u8, f32, 1e0);
	8762	try testArgs(u8, f32, 1e1);
	8763	try testArgs(u8, f32, 1e2);
	8764	try testArgs(u8, f32, next(f32, next(f32, 0x1p8, 0.0), 0.0));
	8765	try testArgs(u8, f32, next(f32, 0x1p8, 0.0));
	8766
	8767	try testArgs(i16, f32, -0x0.8p16);
	8768	try testArgs(i16, f32, next(f32, -0x0.8p16, -0.0));
	8769	try testArgs(i16, f32, next(f32, next(f32, -0x0.8p16, -0.0), -0.0));
	8770	try testArgs(i16, f32, -1e4);
	8771	try testArgs(i16, f32, -1e3);
	8772	try testArgs(i16, f32, -1e2);
	8773	try testArgs(i16, f32, -1e1);
	8774	try testArgs(i16, f32, -1e0);
	8775	try testArgs(i16, f32, -1e-1);
	8776	try testArgs(i16, f32, -0.0);
	8777	try testArgs(i16, f32, 0.0);
	8778	try testArgs(i16, f32, 1e-1);
	8779	try testArgs(i16, f32, 1e0);
	8780	try testArgs(i16, f32, 1e1);
	8781	try testArgs(i16, f32, 1e2);
	8782	try testArgs(i16, f32, 1e3);
	8783	try testArgs(i16, f32, 1e4);
	8784	try testArgs(i16, f32, next(f32, next(f32, 0x0.8p16, 0.0), 0.0));
	8785	try testArgs(i16, f32, next(f32, 0x0.8p16, 0.0));
	8786
	8787	try testArgs(u16, f32, -0.0);
	8788	try testArgs(u16, f32, 0.0);
	8789	try testArgs(u16, f32, 1e-1);
	8790	try testArgs(u16, f32, 1e0);
	8791	try testArgs(u16, f32, 1e1);
	8792	try testArgs(u16, f32, 1e2);
	8793	try testArgs(u16, f32, 1e3);
	8794	try testArgs(u16, f32, 1e4);
	8795	try testArgs(u16, f32, next(f32, next(f32, 0x1p16, 0.0), 0.0));
	8796	try testArgs(u16, f32, next(f32, 0x1p16, 0.0));
	8797
	8798	try testArgs(i32, f32, -0x0.8p32);
	8799	try testArgs(i32, f32, next(f32, -0x0.8p32, -0.0));
	8800	try testArgs(i32, f32, next(f32, next(f32, -0x0.8p32, -0.0), -0.0));
	8801	try testArgs(i32, f32, -1e9);
	8802	try testArgs(i32, f32, -1e8);
	8803	try testArgs(i32, f32, -1e7);
	8804	try testArgs(i32, f32, -1e6);
	8805	try testArgs(i32, f32, -1e5);
	8806	try testArgs(i32, f32, -1e4);
	8807	try testArgs(i32, f32, -1e3);
	8808	try testArgs(i32, f32, -1e2);
	8809	try testArgs(i32, f32, -1e1);
	8810	try testArgs(i32, f32, -1e0);
	8811	try testArgs(i32, f32, -1e-1);
	8812	try testArgs(i32, f32, -0.0);
	8813	try testArgs(i32, f32, 0.0);
	8814	try testArgs(i32, f32, 1e-1);
	8815	try testArgs(i32, f32, 1e0);
	8816	try testArgs(i32, f32, 1e1);
	8817	try testArgs(i32, f32, 1e2);
	8818	try testArgs(i32, f32, 1e3);
	8819	try testArgs(i32, f32, 1e4);
	8820	try testArgs(i32, f32, 1e5);
	8821	try testArgs(i32, f32, 1e6);
	8822	try testArgs(i32, f32, 1e7);
	8823	try testArgs(i32, f32, 1e8);
	8824	try testArgs(i32, f32, 1e9);
	8825	try testArgs(i32, f32, next(f32, next(f32, 0x0.8p32, 0.0), 0.0));
	8826	try testArgs(i32, f32, next(f32, 0x0.8p32, 0.0));
	8827
	8828	try testArgs(u32, f32, -0.0);
	8829	try testArgs(u32, f32, 0.0);
	8830	try testArgs(u32, f32, 1e-1);
	8831	try testArgs(u32, f32, 1e0);
	8832	try testArgs(u32, f32, 1e1);
	8833	try testArgs(u32, f32, 1e2);
	8834	try testArgs(u32, f32, 1e3);
	8835	try testArgs(u32, f32, 1e4);
	8836	try testArgs(u32, f32, 1e5);
	8837	try testArgs(u32, f32, 1e6);
	8838	try testArgs(u32, f32, 1e7);
	8839	try testArgs(u32, f32, 1e8);
	8840	try testArgs(u32, f32, 1e9);
	8841	try testArgs(u32, f32, next(f32, next(f32, 0x1p32, 0.0), 0.0));
	8842	try testArgs(u32, f32, next(f32, 0x1p32, 0.0));
	8843
	8844	try testArgs(i64, f32, -0x0.8p64);
	8845	try testArgs(i64, f32, next(f32, -0x0.8p64, -0.0));
	8846	try testArgs(i64, f32, next(f32, next(f32, -0x0.8p64, -0.0), -0.0));
	8847	try testArgs(i64, f32, -1e18);
	8848	try testArgs(i64, f32, -1e16);
	8849	try testArgs(i64, f32, -1e14);
	8850	try testArgs(i64, f32, -1e12);
	8851	try testArgs(i64, f32, -1e10);
	8852	try testArgs(i64, f32, -1e8);
	8853	try testArgs(i64, f32, -1e6);
	8854	try testArgs(i64, f32, -1e4);
	8855	try testArgs(i64, f32, -1e2);
	8856	try testArgs(i64, f32, -1e0);
	8857	try testArgs(i64, f32, -1e-1);
	8858	try testArgs(i64, f32, -0.0);
	8859	try testArgs(i64, f32, 0.0);
	8860	try testArgs(i64, f32, 1e-1);
	8861	try testArgs(i64, f32, 1e0);
	8862	try testArgs(i64, f32, 1e2);
	8863	try testArgs(i64, f32, 1e4);
	8864	try testArgs(i64, f32, 1e6);
	8865	try testArgs(i64, f32, 1e8);
	8866	try testArgs(i64, f32, 1e10);
	8867	try testArgs(i64, f32, 1e12);
	8868	try testArgs(i64, f32, 1e14);
	8869	try testArgs(i64, f32, 1e16);
	8870	try testArgs(i64, f32, 1e18);
	8871	try testArgs(i64, f32, next(f32, next(f32, 0x0.8p64, 0.0), 0.0));
	8872	try testArgs(i64, f32, next(f32, 0x0.8p64, 0.0));
	8873
	8874	try testArgs(u64, f32, -0.0);
	8875	try testArgs(u64, f32, 0.0);
	8876	try testArgs(u64, f32, 1e-1);
	8877	try testArgs(u64, f32, 1e0);
	8878	try testArgs(u64, f32, 1e2);
	8879	try testArgs(u64, f32, 1e4);
	8880	try testArgs(u64, f32, 1e6);
	8881	try testArgs(u64, f32, 1e8);
	8882	try testArgs(u64, f32, 1e10);
	8883	try testArgs(u64, f32, 1e12);
	8884	try testArgs(u64, f32, 1e14);
	8885	try testArgs(u64, f32, 1e16);
	8886	try testArgs(u64, f32, 1e18);
	8887	try testArgs(u64, f32, next(f32, next(f32, 0x1p64, 0.0), 0.0));
	8888	try testArgs(u64, f32, next(f32, 0x1p64, 0.0));
	8889
	8890	try testArgs(i128, f32, -0x0.8p128);
	8891	try testArgs(i128, f32, next(f32, -0x0.8p128, -0.0));
	8892	try testArgs(i128, f32, next(f32, next(f32, -0x0.8p128, -0.0), -0.0));
	8893	try testArgs(i128, f32, -1e38);
	8894	try testArgs(i128, f32, -1e34);
	8895	try testArgs(i128, f32, -1e30);
	8896	try testArgs(i128, f32, -1e26);
	8897	try testArgs(i128, f32, -1e22);
	8898	try testArgs(i128, f32, -1e18);
	8899	try testArgs(i128, f32, -1e14);
	8900	try testArgs(i128, f32, -1e10);
	8901	try testArgs(i128, f32, -1e6);
	8902	try testArgs(i128, f32, -1e2);
	8903	try testArgs(i128, f32, -1e0);
	8904	try testArgs(i128, f32, -1e-1);
	8905	try testArgs(i128, f32, -0.0);
	8906	try testArgs(i128, f32, 0.0);
	8907	try testArgs(i128, f32, 1e-1);
	8908	try testArgs(i128, f32, 1e0);
	8909	try testArgs(i128, f32, 1e2);
	8910	try testArgs(i128, f32, 1e6);
	8911	try testArgs(i128, f32, 1e10);
	8912	try testArgs(i128, f32, 1e14);
	8913	try testArgs(i128, f32, 1e18);
	8914	try testArgs(i128, f32, 1e22);
	8915	try testArgs(i128, f32, 1e26);
	8916	try testArgs(i128, f32, 1e30);
	8917	try testArgs(i128, f32, 1e34);
	8918	try testArgs(i128, f32, 1e38);
	8919	try testArgs(i128, f32, next(f32, next(f32, 0x0.8p128, 0.0), 0.0));
	8920	try testArgs(i128, f32, next(f32, 0x0.8p128, 0.0));
	8921
	8922	try testArgs(u128, f32, -0.0);
	8923	try testArgs(u128, f32, 0.0);
	8924	try testArgs(u128, f32, 1e-1);
	8925	try testArgs(u128, f32, 1e0);
	8926	try testArgs(u128, f32, 1e2);
	8927	try testArgs(u128, f32, 1e6);
	8928	try testArgs(u128, f32, 1e10);
	8929	try testArgs(u128, f32, 1e14);
	8930	try testArgs(u128, f32, 1e18);
	8931	try testArgs(u128, f32, 1e22);
	8932	try testArgs(u128, f32, 1e26);
	8933	try testArgs(u128, f32, 1e30);
	8934	try testArgs(u128, f32, 1e34);
	8935	try testArgs(u128, f32, 1e38);
	8936	try testArgs(u128, f32, next(f32, next(f32, fmax(f32), 0.0), 0.0));
	8937	try testArgs(u128, f32, next(f32, fmax(f32), 0.0));
	8938
	8939	try testArgs(i256, f32, -fmax(f32));
	8940	try testArgs(i256, f32, next(f32, -fmax(f32), -0.0));
	8941	try testArgs(i256, f32, next(f32, next(f32, -fmax(f32), -0.0), -0.0));
	8942	try testArgs(i256, f32, -1e38);
	8943	try testArgs(i256, f32, -1e34);
	8944	try testArgs(i256, f32, -1e30);
	8945	try testArgs(i256, f32, -1e26);
	8946	try testArgs(i256, f32, -1e22);
	8947	try testArgs(i256, f32, -1e18);
	8948	try testArgs(i256, f32, -1e14);
	8949	try testArgs(i256, f32, -1e10);
	8950	try testArgs(i256, f32, -1e6);
	8951	try testArgs(i256, f32, -1e2);
	8952	try testArgs(i256, f32, -1e0);
	8953	try testArgs(i256, f32, -1e-1);
	8954	try testArgs(i256, f32, -0.0);
	8955	try testArgs(i256, f32, 0.0);
	8956	try testArgs(i256, f32, 1e-1);
	8957	try testArgs(i256, f32, 1e0);
	8958	try testArgs(i256, f32, 1e2);
	8959	try testArgs(i256, f32, 1e6);
	8960	try testArgs(i256, f32, 1e10);
	8961	try testArgs(i256, f32, 1e14);
	8962	try testArgs(i256, f32, 1e18);
	8963	try testArgs(i256, f32, 1e22);
	8964	try testArgs(i256, f32, 1e26);
	8965	try testArgs(i256, f32, 1e30);
	8966	try testArgs(i256, f32, 1e34);
	8967	try testArgs(i256, f32, 1e38);
	8968	try testArgs(i256, f32, next(f32, next(f32, fmax(f32), 0.0), 0.0));
	8969	try testArgs(i256, f32, next(f32, fmax(f32), 0.0));
	8970
	8971	try testArgs(u256, f32, -0.0);
	8972	try testArgs(u256, f32, 0.0);
	8973	try testArgs(u256, f32, 1e-1);
	8974	try testArgs(u256, f32, 1e0);
	8975	try testArgs(u256, f32, 1e2);
	8976	try testArgs(u256, f32, 1e6);
	8977	try testArgs(u256, f32, 1e10);
	8978	try testArgs(u256, f32, 1e14);
	8979	try testArgs(u256, f32, 1e18);
	8980	try testArgs(u256, f32, 1e22);
	8981	try testArgs(u256, f32, 1e26);
	8982	try testArgs(u256, f32, 1e30);
	8983	try testArgs(u256, f32, 1e34);
	8984	try testArgs(u256, f32, 1e38);
	8985	try testArgs(u256, f32, next(f32, next(f32, fmax(f32), 0.0), 0.0));
	8986	try testArgs(u256, f32, next(f32, fmax(f32), 0.0));
	8987
	8988	try testArgs(i8, f64, -0x0.8p8);
	8989	try testArgs(i8, f64, next(f64, -0x0.8p8, -0.0));
	8990	try testArgs(i8, f64, next(f64, next(f64, -0x0.8p8, -0.0), -0.0));
	8991	try testArgs(i8, f64, -1e2);
	8992	try testArgs(i8, f64, -1e1);
	8993	try testArgs(i8, f64, -1e0);
	8994	try testArgs(i8, f64, -1e-1);
	8995	try testArgs(i8, f64, -0.0);
	8996	try testArgs(i8, f64, 0.0);
	8997	try testArgs(i8, f64, 1e-1);
	8998	try testArgs(i8, f64, 1e0);
	8999	try testArgs(i8, f64, 1e1);
	9000	try testArgs(i8, f64, 1e2);
	9001	try testArgs(i8, f64, next(f64, next(f64, 0x0.8p8, 0.0), 0.0));
	9002	try testArgs(i8, f64, next(f64, 0x0.8p8, 0.0));
	9003
	9004	try testArgs(u8, f64, -0.0);
	9005	try testArgs(u8, f64, 0.0);
	9006	try testArgs(u8, f64, 1e-1);
	9007	try testArgs(u8, f64, 1e0);
	9008	try testArgs(u8, f64, 1e1);
	9009	try testArgs(u8, f64, 1e2);
	9010	try testArgs(u8, f64, next(f64, next(f64, 0x1p8, 0.0), 0.0));
	9011	try testArgs(u8, f64, next(f64, 0x1p8, 0.0));
	9012
	9013	try testArgs(i16, f64, -0x0.8p16);
	9014	try testArgs(i16, f64, next(f64, -0x0.8p16, -0.0));
	9015	try testArgs(i16, f64, next(f64, next(f64, -0x0.8p16, -0.0), -0.0));
	9016	try testArgs(i16, f64, -1e4);
	9017	try testArgs(i16, f64, -1e3);
	9018	try testArgs(i16, f64, -1e2);
	9019	try testArgs(i16, f64, -1e1);
	9020	try testArgs(i16, f64, -1e0);
	9021	try testArgs(i16, f64, -1e-1);
	9022	try testArgs(i16, f64, -0.0);
	9023	try testArgs(i16, f64, 0.0);
	9024	try testArgs(i16, f64, 1e-1);
	9025	try testArgs(i16, f64, 1e0);
	9026	try testArgs(i16, f64, 1e1);
	9027	try testArgs(i16, f64, 1e2);
	9028	try testArgs(i16, f64, 1e3);
	9029	try testArgs(i16, f64, 1e4);
	9030	try testArgs(i16, f64, next(f64, next(f64, 0x0.8p16, 0.0), 0.0));
	9031	try testArgs(i16, f64, next(f64, 0x0.8p16, 0.0));
	9032
	9033	try testArgs(u16, f64, -0.0);
	9034	try testArgs(u16, f64, 0.0);
	9035	try testArgs(u16, f64, 1e-1);
	9036	try testArgs(u16, f64, 1e0);
	9037	try testArgs(u16, f64, 1e1);
	9038	try testArgs(u16, f64, 1e2);
	9039	try testArgs(u16, f64, 1e3);
	9040	try testArgs(u16, f64, 1e4);
	9041	try testArgs(u16, f64, next(f64, next(f64, 0x1p16, 0.0), 0.0));
	9042	try testArgs(u16, f64, next(f64, 0x1p16, 0.0));
	9043
	9044	try testArgs(i32, f64, -0x0.8p32);
	9045	try testArgs(i32, f64, next(f64, -0x0.8p32, -0.0));
	9046	try testArgs(i32, f64, next(f64, next(f64, -0x0.8p32, -0.0), -0.0));
	9047	try testArgs(i32, f64, -1e9);
	9048	try testArgs(i32, f64, -1e8);
	9049	try testArgs(i32, f64, -1e7);
	9050	try testArgs(i32, f64, -1e6);
	9051	try testArgs(i32, f64, -1e5);
	9052	try testArgs(i32, f64, -1e4);
	9053	try testArgs(i32, f64, -1e3);
	9054	try testArgs(i32, f64, -1e2);
	9055	try testArgs(i32, f64, -1e1);
	9056	try testArgs(i32, f64, -1e0);
	9057	try testArgs(i32, f64, -1e-1);
	9058	try testArgs(i32, f64, -0.0);
	9059	try testArgs(i32, f64, 0.0);
	9060	try testArgs(i32, f64, 1e-1);
	9061	try testArgs(i32, f64, 1e0);
	9062	try testArgs(i32, f64, 1e1);
	9063	try testArgs(i32, f64, 1e2);
	9064	try testArgs(i32, f64, 1e3);
	9065	try testArgs(i32, f64, 1e4);
	9066	try testArgs(i32, f64, 1e5);
	9067	try testArgs(i32, f64, 1e6);
	9068	try testArgs(i32, f64, 1e7);
	9069	try testArgs(i32, f64, 1e8);
	9070	try testArgs(i32, f64, 1e9);
	9071	try testArgs(i32, f64, next(f64, next(f64, 0x0.8p32, 0.0), 0.0));
	9072	try testArgs(i32, f64, next(f64, 0x0.8p32, 0.0));
	9073
	9074	try testArgs(u32, f64, -0.0);
	9075	try testArgs(u32, f64, 0.0);
	9076	try testArgs(u32, f64, 1e-1);
	9077	try testArgs(u32, f64, 1e0);
	9078	try testArgs(u32, f64, 1e1);
	9079	try testArgs(u32, f64, 1e2);
	9080	try testArgs(u32, f64, 1e3);
	9081	try testArgs(u32, f64, 1e4);
	9082	try testArgs(u32, f64, 1e5);
	9083	try testArgs(u32, f64, 1e6);
	9084	try testArgs(u32, f64, 1e7);
	9085	try testArgs(u32, f64, 1e8);
	9086	try testArgs(u32, f64, 1e9);
	9087	try testArgs(u32, f64, next(f64, next(f64, 0x1p32, 0.0), 0.0));
	9088	try testArgs(u32, f64, next(f64, 0x1p32, 0.0));
	9089
	9090	try testArgs(i64, f64, -0x0.8p64);
	9091	try testArgs(i64, f64, next(f64, -0x0.8p64, -0.0));
	9092	try testArgs(i64, f64, next(f64, next(f64, -0x0.8p64, -0.0), -0.0));
	9093	try testArgs(i64, f64, -1e18);
	9094	try testArgs(i64, f64, -1e16);
	9095	try testArgs(i64, f64, -1e14);
	9096	try testArgs(i64, f64, -1e12);
	9097	try testArgs(i64, f64, -1e10);
	9098	try testArgs(i64, f64, -1e8);
	9099	try testArgs(i64, f64, -1e6);
	9100	try testArgs(i64, f64, -1e4);
	9101	try testArgs(i64, f64, -1e2);
	9102	try testArgs(i64, f64, -1e0);
	9103	try testArgs(i64, f64, -1e-1);
	9104	try testArgs(i64, f64, -0.0);
	9105	try testArgs(i64, f64, 0.0);
	9106	try testArgs(i64, f64, 1e-1);
	9107	try testArgs(i64, f64, 1e0);
	9108	try testArgs(i64, f64, 1e2);
	9109	try testArgs(i64, f64, 1e4);
	9110	try testArgs(i64, f64, 1e6);
	9111	try testArgs(i64, f64, 1e8);
	9112	try testArgs(i64, f64, 1e10);
	9113	try testArgs(i64, f64, 1e12);
	9114	try testArgs(i64, f64, 1e14);
	9115	try testArgs(i64, f64, 1e16);
	9116	try testArgs(i64, f64, 1e18);
	9117	try testArgs(i64, f64, next(f64, next(f64, 0x0.8p64, 0.0), 0.0));
	9118	try testArgs(i64, f64, next(f64, 0x0.8p64, 0.0));
	9119
	9120	try testArgs(u64, f64, -0.0);
	9121	try testArgs(u64, f64, 0.0);
	9122	try testArgs(u64, f64, 1e-1);
	9123	try testArgs(u64, f64, 1e0);
	9124	try testArgs(u64, f64, 1e2);
	9125	try testArgs(u64, f64, 1e4);
	9126	try testArgs(u64, f64, 1e6);
	9127	try testArgs(u64, f64, 1e8);
	9128	try testArgs(u64, f64, 1e10);
	9129	try testArgs(u64, f64, 1e12);
	9130	try testArgs(u64, f64, 1e14);
	9131	try testArgs(u64, f64, 1e16);
	9132	try testArgs(u64, f64, 1e18);
	9133	try testArgs(u64, f64, next(f64, next(f64, 0x1p64, 0.0), 0.0));
	9134	try testArgs(u64, f64, next(f64, 0x1p64, 0.0));
	9135
	9136	try testArgs(i128, f64, -0x0.8p128);
	9137	try testArgs(i128, f64, next(f64, -0x0.8p128, -0.0));
	9138	try testArgs(i128, f64, next(f64, next(f64, -0x0.8p128, -0.0), -0.0));
	9139	try testArgs(i128, f64, -1e38);
	9140	try testArgs(i128, f64, -1e34);
	9141	try testArgs(i128, f64, -1e30);
	9142	try testArgs(i128, f64, -1e26);
	9143	try testArgs(i128, f64, -1e22);
	9144	try testArgs(i128, f64, -1e18);
	9145	try testArgs(i128, f64, -1e14);
	9146	try testArgs(i128, f64, -1e10);
	9147	try testArgs(i128, f64, -1e6);
	9148	try testArgs(i128, f64, -1e2);
	9149	try testArgs(i128, f64, -1e0);
	9150	try testArgs(i128, f64, -1e-1);
	9151	try testArgs(i128, f64, -0.0);
	9152	try testArgs(i128, f64, 0.0);
	9153	try testArgs(i128, f64, 1e-1);
	9154	try testArgs(i128, f64, 1e0);
	9155	try testArgs(i128, f64, 1e2);
	9156	try testArgs(i128, f64, 1e6);
	9157	try testArgs(i128, f64, 1e10);
	9158	try testArgs(i128, f64, 1e14);
	9159	try testArgs(i128, f64, 1e18);
	9160	try testArgs(i128, f64, 1e22);
	9161	try testArgs(i128, f64, 1e26);
	9162	try testArgs(i128, f64, 1e30);
	9163	try testArgs(i128, f64, 1e34);
	9164	try testArgs(i128, f64, 1e38);
	9165	try testArgs(i128, f64, next(f64, next(f64, 0x0.8p128, 0.0), 0.0));
	9166	try testArgs(i128, f64, next(f64, 0x0.8p128, 0.0));
	9167
	9168	try testArgs(u128, f64, -0.0);
	9169	try testArgs(u128, f64, 0.0);
	9170	try testArgs(u128, f64, 1e-1);
	9171	try testArgs(u128, f64, 1e0);
	9172	try testArgs(u128, f64, 1e2);
	9173	try testArgs(u128, f64, 1e6);
	9174	try testArgs(u128, f64, 1e10);
	9175	try testArgs(u128, f64, 1e14);
	9176	try testArgs(u128, f64, 1e18);
	9177	try testArgs(u128, f64, 1e22);
	9178	try testArgs(u128, f64, 1e26);
	9179	try testArgs(u128, f64, 1e30);
	9180	try testArgs(u128, f64, 1e34);
	9181	try testArgs(u128, f64, 1e38);
	9182	try testArgs(u128, f64, next(f64, next(f64, 0x1p128, 0.0), 0.0));
	9183	try testArgs(u128, f64, next(f64, 0x1p128, 0.0));
	9184
	9185	try testArgs(i256, f64, -0x0.8p256);
	9186	try testArgs(i256, f64, next(f64, -0x0.8p256, -0.0));
	9187	try testArgs(i256, f64, next(f64, next(f64, -0x0.8p256, -0.0), -0.0));
	9188	try testArgs(i256, f64, -1e76);
	9189	try testArgs(i256, f64, -1e69);
	9190	try testArgs(i256, f64, -1e62);
	9191	try testArgs(i256, f64, -1e55);
	9192	try testArgs(i256, f64, -1e48);
	9193	try testArgs(i256, f64, -1e41);
	9194	try testArgs(i256, f64, -1e34);
	9195	try testArgs(i256, f64, -1e27);
	9196	try testArgs(i256, f64, -1e20);
	9197	try testArgs(i256, f64, -1e13);
	9198	try testArgs(i256, f64, -1e6);
	9199	try testArgs(i256, f64, -1e0);
	9200	try testArgs(i256, f64, -1e-1);
	9201	try testArgs(i256, f64, -0.0);
	9202	try testArgs(i256, f64, 0.0);
	9203	try testArgs(i256, f64, 1e-1);
	9204	try testArgs(i256, f64, 1e0);
	9205	try testArgs(i256, f64, 1e6);
	9206	try testArgs(i256, f64, 1e13);
	9207	try testArgs(i256, f64, 1e20);
	9208	try testArgs(i256, f64, 1e27);
	9209	try testArgs(i256, f64, 1e34);
	9210	try testArgs(i256, f64, 1e41);
	9211	try testArgs(i256, f64, 1e48);
	9212	try testArgs(i256, f64, 1e55);
	9213	try testArgs(i256, f64, 1e62);
	9214	try testArgs(i256, f64, 1e69);
	9215	try testArgs(i256, f64, 1e76);
	9216	try testArgs(i256, f64, next(f64, next(f64, 0x0.8p256, 0.0), 0.0));
	9217	try testArgs(i256, f64, next(f64, 0x0.8p256, 0.0));
	9218
	9219	try testArgs(u256, f64, -0.0);
	9220	try testArgs(u256, f64, 0.0);
	9221	try testArgs(u256, f64, 1e-1);
	9222	try testArgs(u256, f64, 1e0);
	9223	try testArgs(u256, f64, 1e7);
	9224	try testArgs(u256, f64, 1e14);
	9225	try testArgs(u256, f64, 1e21);
	9226	try testArgs(u256, f64, 1e28);
	9227	try testArgs(u256, f64, 1e35);
	9228	try testArgs(u256, f64, 1e42);
	9229	try testArgs(u256, f64, 1e49);
	9230	try testArgs(u256, f64, 1e56);
	9231	try testArgs(u256, f64, 1e63);
	9232	try testArgs(u256, f64, 1e70);
	9233	try testArgs(u256, f64, 1e77);
	9234	try testArgs(u256, f64, next(f64, next(f64, 0x1p256, 0.0), 0.0));
	9235	try testArgs(u256, f64, next(f64, 0x1p256, 0.0));
	9236
	9237	try testArgs(i8, f80, -0x0.8p8);
	9238	try testArgs(i8, f80, next(f80, -0x0.8p8, -0.0));
	9239	try testArgs(i8, f80, next(f80, next(f80, -0x0.8p8, -0.0), -0.0));
	9240	try testArgs(i8, f80, -1e2);
	9241	try testArgs(i8, f80, -1e1);
	9242	try testArgs(i8, f80, -1e0);
	9243	try testArgs(i8, f80, -1e-1);
	9244	try testArgs(i8, f80, -0.0);
	9245	try testArgs(i8, f80, 0.0);
	9246	try testArgs(i8, f80, 1e-1);
	9247	try testArgs(i8, f80, 1e0);
	9248	try testArgs(i8, f80, 1e1);
	9249	try testArgs(i8, f80, 1e2);
	9250	try testArgs(i8, f80, next(f80, next(f80, 0x0.8p8, 0.0), 0.0));
	9251	try testArgs(i8, f80, next(f80, 0x0.8p8, 0.0));
	9252
	9253	try testArgs(u8, f80, -0.0);
	9254	try testArgs(u8, f80, 0.0);
	9255	try testArgs(u8, f80, 1e-1);
	9256	try testArgs(u8, f80, 1e0);
	9257	try testArgs(u8, f80, 1e1);
	9258	try testArgs(u8, f80, 1e2);
	9259	try testArgs(u8, f80, next(f80, next(f80, 0x1p8, 0.0), 0.0));
	9260	try testArgs(u8, f80, next(f80, 0x1p8, 0.0));
	9261
	9262	try testArgs(i16, f80, -0x0.8p16);
	9263	try testArgs(i16, f80, next(f80, -0x0.8p16, -0.0));
	9264	try testArgs(i16, f80, next(f80, next(f80, -0x0.8p16, -0.0), -0.0));
	9265	try testArgs(i16, f80, -1e4);
	9266	try testArgs(i16, f80, -1e3);
	9267	try testArgs(i16, f80, -1e2);
	9268	try testArgs(i16, f80, -1e1);
	9269	try testArgs(i16, f80, -1e0);
	9270	try testArgs(i16, f80, -1e-1);
	9271	try testArgs(i16, f80, -0.0);
	9272	try testArgs(i16, f80, 0.0);
	9273	try testArgs(i16, f80, 1e-1);
	9274	try testArgs(i16, f80, 1e0);
	9275	try testArgs(i16, f80, 1e1);
	9276	try testArgs(i16, f80, 1e2);
	9277	try testArgs(i16, f80, 1e3);
	9278	try testArgs(i16, f80, 1e4);
	9279	try testArgs(i16, f80, next(f80, next(f80, 0x0.8p16, 0.0), 0.0));
	9280	try testArgs(i16, f80, next(f80, 0x0.8p16, 0.0));
	9281
	9282	try testArgs(u16, f80, -0.0);
	9283	try testArgs(u16, f80, 0.0);
	9284	try testArgs(u16, f80, 1e-1);
	9285	try testArgs(u16, f80, 1e0);
	9286	try testArgs(u16, f80, 1e1);
	9287	try testArgs(u16, f80, 1e2);
	9288	try testArgs(u16, f80, 1e3);
	9289	try testArgs(u16, f80, 1e4);
	9290	try testArgs(u16, f80, next(f80, next(f80, 0x1p16, 0.0), 0.0));
	9291	try testArgs(u16, f80, next(f80, 0x1p16, 0.0));
	9292
	9293	try testArgs(i32, f80, -0x0.8p32);
	9294	try testArgs(i32, f80, next(f80, -0x0.8p32, -0.0));
	9295	try testArgs(i32, f80, next(f80, next(f80, -0x0.8p32, -0.0), -0.0));
	9296	try testArgs(i32, f80, -1e9);
	9297	try testArgs(i32, f80, -1e8);
	9298	try testArgs(i32, f80, -1e7);
	9299	try testArgs(i32, f80, -1e6);
	9300	try testArgs(i32, f80, -1e5);
	9301	try testArgs(i32, f80, -1e4);
	9302	try testArgs(i32, f80, -1e3);
	9303	try testArgs(i32, f80, -1e2);
	9304	try testArgs(i32, f80, -1e1);
	9305	try testArgs(i32, f80, -1e0);
	9306	try testArgs(i32, f80, -1e-1);
	9307	try testArgs(i32, f80, -0.0);
	9308	try testArgs(i32, f80, 0.0);
	9309	try testArgs(i32, f80, 1e-1);
	9310	try testArgs(i32, f80, 1e0);
	9311	try testArgs(i32, f80, 1e1);
	9312	try testArgs(i32, f80, 1e2);
	9313	try testArgs(i32, f80, 1e3);
	9314	try testArgs(i32, f80, 1e4);
	9315	try testArgs(i32, f80, 1e5);
	9316	try testArgs(i32, f80, 1e6);
	9317	try testArgs(i32, f80, 1e7);
	9318	try testArgs(i32, f80, 1e8);
	9319	try testArgs(i32, f80, 1e9);
	9320	try testArgs(i32, f80, next(f80, next(f80, 0x0.8p32, 0.0), 0.0));
	9321	try testArgs(i32, f80, next(f80, 0x0.8p32, 0.0));
	9322
	9323	try testArgs(u32, f80, -0.0);
	9324	try testArgs(u32, f80, 0.0);
	9325	try testArgs(u32, f80, 1e-1);
	9326	try testArgs(u32, f80, 1e0);
	9327	try testArgs(u32, f80, 1e1);
	9328	try testArgs(u32, f80, 1e2);
	9329	try testArgs(u32, f80, 1e3);
	9330	try testArgs(u32, f80, 1e4);
	9331	try testArgs(u32, f80, 1e5);
	9332	try testArgs(u32, f80, 1e6);
	9333	try testArgs(u32, f80, 1e7);
	9334	try testArgs(u32, f80, 1e8);
	9335	try testArgs(u32, f80, 1e9);
	9336	try testArgs(u32, f80, next(f80, next(f80, 0x1p32, 0.0), 0.0));
	9337	try testArgs(u32, f80, next(f80, 0x1p32, 0.0));
	9338
	9339	try testArgs(i64, f80, -0x0.8p64);
	9340	try testArgs(i64, f80, next(f80, -0x0.8p64, -0.0));
	9341	try testArgs(i64, f80, next(f80, next(f80, -0x0.8p64, -0.0), -0.0));
	9342	try testArgs(i64, f80, -1e18);
	9343	try testArgs(i64, f80, -1e16);
	9344	try testArgs(i64, f80, -1e14);
	9345	try testArgs(i64, f80, -1e12);
	9346	try testArgs(i64, f80, -1e10);
	9347	try testArgs(i64, f80, -1e8);
	9348	try testArgs(i64, f80, -1e6);
	9349	try testArgs(i64, f80, -1e4);
	9350	try testArgs(i64, f80, -1e2);
	9351	try testArgs(i64, f80, -1e0);
	9352	try testArgs(i64, f80, -1e-1);
	9353	try testArgs(i64, f80, -0.0);
	9354	try testArgs(i64, f80, 0.0);
	9355	try testArgs(i64, f80, 1e-1);
	9356	try testArgs(i64, f80, 1e0);
	9357	try testArgs(i64, f80, 1e2);
	9358	try testArgs(i64, f80, 1e4);
	9359	try testArgs(i64, f80, 1e6);
	9360	try testArgs(i64, f80, 1e8);
	9361	try testArgs(i64, f80, 1e10);
	9362	try testArgs(i64, f80, 1e12);
	9363	try testArgs(i64, f80, 1e14);
	9364	try testArgs(i64, f80, 1e16);
	9365	try testArgs(i64, f80, 1e18);
	9366	try testArgs(i64, f80, next(f80, next(f80, 0x0.8p64, 0.0), 0.0));
	9367	try testArgs(i64, f80, next(f80, 0x0.8p64, 0.0));
	9368
	9369	try testArgs(u64, f80, -0.0);
	9370	try testArgs(u64, f80, 0.0);
	9371	try testArgs(u64, f80, 1e-1);
	9372	try testArgs(u64, f80, 1e0);
	9373	try testArgs(u64, f80, 1e2);
	9374	try testArgs(u64, f80, 1e4);
	9375	try testArgs(u64, f80, 1e6);
	9376	try testArgs(u64, f80, 1e8);
	9377	try testArgs(u64, f80, 1e10);
	9378	try testArgs(u64, f80, 1e12);
	9379	try testArgs(u64, f80, 1e14);
	9380	try testArgs(u64, f80, 1e16);
	9381	try testArgs(u64, f80, 1e18);
	9382	try testArgs(u64, f80, next(f80, next(f80, 0x1p64, 0.0), 0.0));
	9383	try testArgs(u64, f80, next(f80, 0x1p64, 0.0));
	9384
	9385	try testArgs(i128, f80, -0x0.8p128);
	9386	try testArgs(i128, f80, next(f80, -0x0.8p128, -0.0));
	9387	try testArgs(i128, f80, next(f80, next(f80, -0x0.8p128, -0.0), -0.0));
	9388	try testArgs(i128, f80, -1e38);
	9389	try testArgs(i128, f80, -1e34);
	9390	try testArgs(i128, f80, -1e30);
	9391	try testArgs(i128, f80, -1e26);
	9392	try testArgs(i128, f80, -1e22);
	9393	try testArgs(i128, f80, -1e18);
	9394	try testArgs(i128, f80, -1e14);
	9395	try testArgs(i128, f80, -1e10);
	9396	try testArgs(i128, f80, -1e6);
	9397	try testArgs(i128, f80, -1e2);
	9398	try testArgs(i128, f80, -1e0);
	9399	try testArgs(i128, f80, -1e-1);
	9400	try testArgs(i128, f80, -0.0);
	9401	try testArgs(i128, f80, 0.0);
	9402	try testArgs(i128, f80, 1e-1);
	9403	try testArgs(i128, f80, 1e0);
	9404	try testArgs(i128, f80, 1e2);
	9405	try testArgs(i128, f80, 1e6);
	9406	try testArgs(i128, f80, 1e10);
	9407	try testArgs(i128, f80, 1e14);
	9408	try testArgs(i128, f80, 1e18);
	9409	try testArgs(i128, f80, 1e22);
	9410	try testArgs(i128, f80, 1e26);
	9411	try testArgs(i128, f80, 1e30);
	9412	try testArgs(i128, f80, 1e34);
	9413	try testArgs(i128, f80, 1e38);
	9414	try testArgs(i128, f80, next(f80, next(f80, 0x0.8p128, 0.0), 0.0));
	9415	try testArgs(i128, f80, next(f80, 0x0.8p128, 0.0));
	9416
	9417	try testArgs(u128, f80, -0.0);
	9418	try testArgs(u128, f80, 0.0);
	9419	try testArgs(u128, f80, 1e-1);
	9420	try testArgs(u128, f80, 1e0);
	9421	try testArgs(u128, f80, 1e2);
	9422	try testArgs(u128, f80, 1e6);
	9423	try testArgs(u128, f80, 1e10);
	9424	try testArgs(u128, f80, 1e14);
	9425	try testArgs(u128, f80, 1e18);
	9426	try testArgs(u128, f80, 1e22);
	9427	try testArgs(u128, f80, 1e26);
	9428	try testArgs(u128, f80, 1e30);
	9429	try testArgs(u128, f80, 1e34);
	9430	try testArgs(u128, f80, 1e38);
	9431	try testArgs(u128, f80, next(f80, next(f80, 0x1p128, 0.0), 0.0));
	9432	try testArgs(u128, f80, next(f80, 0x1p128, 0.0));
	9433
	9434	try testArgs(i256, f80, -0x0.8p256);
	9435	try testArgs(i256, f80, next(f80, -0x0.8p256, -0.0));
	9436	try testArgs(i256, f80, next(f80, next(f80, -0x0.8p256, -0.0), -0.0));
	9437	try testArgs(i256, f80, -1e76);
	9438	try testArgs(i256, f80, -1e69);
	9439	try testArgs(i256, f80, -1e62);
	9440	try testArgs(i256, f80, -1e55);
	9441	try testArgs(i256, f80, -1e48);
	9442	try testArgs(i256, f80, -1e41);
	9443	try testArgs(i256, f80, -1e34);
	9444	try testArgs(i256, f80, -1e27);
	9445	try testArgs(i256, f80, -1e20);
	9446	try testArgs(i256, f80, -1e13);
	9447	try testArgs(i256, f80, -1e6);
	9448	try testArgs(i256, f80, -1e0);
	9449	try testArgs(i256, f80, -1e-1);
	9450	try testArgs(i256, f80, -0.0);
	9451	try testArgs(i256, f80, 0.0);
	9452	try testArgs(i256, f80, 1e-1);
	9453	try testArgs(i256, f80, 1e0);
	9454	try testArgs(i256, f80, 1e6);
	9455	try testArgs(i256, f80, 1e13);
	9456	try testArgs(i256, f80, 1e20);
	9457	try testArgs(i256, f80, 1e27);
	9458	try testArgs(i256, f80, 1e34);
	9459	try testArgs(i256, f80, 1e41);
	9460	try testArgs(i256, f80, 1e48);
	9461	try testArgs(i256, f80, 1e55);
	9462	try testArgs(i256, f80, 1e62);
	9463	try testArgs(i256, f80, 1e69);
	9464	try testArgs(i256, f80, 1e76);
	9465	try testArgs(i256, f80, next(f80, next(f80, 0x0.8p256, 0.0), 0.0));
	9466	try testArgs(i256, f80, next(f80, 0x0.8p256, 0.0));
	9467
	9468	try testArgs(u256, f80, -0.0);
	9469	try testArgs(u256, f80, 0.0);
	9470	try testArgs(u256, f80, 1e-1);
	9471	try testArgs(u256, f80, 1e0);
	9472	try testArgs(u256, f80, 1e7);
	9473	try testArgs(u256, f80, 1e14);
	9474	try testArgs(u256, f80, 1e21);
	9475	try testArgs(u256, f80, 1e28);
	9476	try testArgs(u256, f80, 1e35);
	9477	try testArgs(u256, f80, 1e42);
	9478	try testArgs(u256, f80, 1e49);
	9479	try testArgs(u256, f80, 1e56);
	9480	try testArgs(u256, f80, 1e63);
	9481	try testArgs(u256, f80, 1e70);
	9482	try testArgs(u256, f80, 1e77);
	9483	try testArgs(u256, f80, next(f80, next(f80, 0x1p256, 0.0), 0.0));
	9484	try testArgs(u256, f80, next(f80, 0x1p256, 0.0));
	9485
	9486	try testArgs(i8, f128, -0x0.8p8);
	9487	try testArgs(i8, f128, next(f128, -0x0.8p8, -0.0));
	9488	try testArgs(i8, f128, next(f128, next(f128, -0x0.8p8, -0.0), -0.0));
	9489	try testArgs(i8, f128, -1e2);
	9490	try testArgs(i8, f128, -1e1);
	9491	try testArgs(i8, f128, -1e0);
	9492	try testArgs(i8, f128, -1e-1);
	9493	try testArgs(i8, f128, -0.0);
	9494	try testArgs(i8, f128, 0.0);
	9495	try testArgs(i8, f128, 1e-1);
	9496	try testArgs(i8, f128, 1e0);
	9497	try testArgs(i8, f128, 1e1);
	9498	try testArgs(i8, f128, 1e2);
	9499	try testArgs(i8, f128, next(f128, next(f128, 0x0.8p8, 0.0), 0.0));
	9500	try testArgs(i8, f128, next(f128, 0x0.8p8, 0.0));
	9501
	9502	try testArgs(u8, f128, -0.0);
	9503	try testArgs(u8, f128, 0.0);
	9504	try testArgs(u8, f128, 1e-1);
	9505	try testArgs(u8, f128, 1e0);
	9506	try testArgs(u8, f128, 1e1);
	9507	try testArgs(u8, f128, 1e2);
	9508	try testArgs(u8, f128, next(f128, next(f128, 0x1p8, 0.0), 0.0));
	9509	try testArgs(u8, f128, next(f128, 0x1p8, 0.0));
	9510
	9511	try testArgs(i16, f128, -0x0.8p16);
	9512	try testArgs(i16, f128, next(f128, -0x0.8p16, -0.0));
	9513	try testArgs(i16, f128, next(f128, next(f128, -0x0.8p16, -0.0), -0.0));
	9514	try testArgs(i16, f128, -1e4);
	9515	try testArgs(i16, f128, -1e3);
	9516	try testArgs(i16, f128, -1e2);
	9517	try testArgs(i16, f128, -1e1);
	9518	try testArgs(i16, f128, -1e0);
	9519	try testArgs(i16, f128, -1e-1);
	9520	try testArgs(i16, f128, -0.0);
	9521	try testArgs(i16, f128, 0.0);
	9522	try testArgs(i16, f128, 1e-1);
	9523	try testArgs(i16, f128, 1e0);
	9524	try testArgs(i16, f128, 1e1);
	9525	try testArgs(i16, f128, 1e2);
	9526	try testArgs(i16, f128, 1e3);
	9527	try testArgs(i16, f128, 1e4);
	9528	try testArgs(i16, f128, next(f128, next(f128, 0x0.8p16, 0.0), 0.0));
	9529	try testArgs(i16, f128, next(f128, 0x0.8p16, 0.0));
	9530
	9531	try testArgs(u16, f128, -0.0);
	9532	try testArgs(u16, f128, 0.0);
	9533	try testArgs(u16, f128, 1e-1);
	9534	try testArgs(u16, f128, 1e0);
	9535	try testArgs(u16, f128, 1e1);
	9536	try testArgs(u16, f128, 1e2);
	9537	try testArgs(u16, f128, 1e3);
	9538	try testArgs(u16, f128, 1e4);
	9539	try testArgs(u16, f128, next(f128, next(f128, 0x1p16, 0.0), 0.0));
	9540	try testArgs(u16, f128, next(f128, 0x1p16, 0.0));
	9541
	9542	try testArgs(i32, f128, -0x0.8p32);
	9543	try testArgs(i32, f128, next(f128, -0x0.8p32, -0.0));
	9544	try testArgs(i32, f128, next(f128, next(f128, -0x0.8p32, -0.0), -0.0));
	9545	try testArgs(i32, f128, -1e9);
	9546	try testArgs(i32, f128, -1e8);
	9547	try testArgs(i32, f128, -1e7);
	9548	try testArgs(i32, f128, -1e6);
	9549	try testArgs(i32, f128, -1e5);
	9550	try testArgs(i32, f128, -1e4);
	9551	try testArgs(i32, f128, -1e3);
	9552	try testArgs(i32, f128, -1e2);
	9553	try testArgs(i32, f128, -1e1);
	9554	try testArgs(i32, f128, -1e0);
	9555	try testArgs(i32, f128, -1e-1);
	9556	try testArgs(i32, f128, -0.0);
	9557	try testArgs(i32, f128, 0.0);
	9558	try testArgs(i32, f128, 1e-1);
	9559	try testArgs(i32, f128, 1e0);
	9560	try testArgs(i32, f128, 1e1);
	9561	try testArgs(i32, f128, 1e2);
	9562	try testArgs(i32, f128, 1e3);
	9563	try testArgs(i32, f128, 1e4);
	9564	try testArgs(i32, f128, 1e5);
	9565	try testArgs(i32, f128, 1e6);
	9566	try testArgs(i32, f128, 1e7);
	9567	try testArgs(i32, f128, 1e8);
	9568	try testArgs(i32, f128, 1e9);
	9569	try testArgs(i32, f128, next(f128, next(f128, 0x0.8p32, 0.0), 0.0));
	9570	try testArgs(i32, f128, next(f128, 0x0.8p32, 0.0));
	9571
	9572	try testArgs(u32, f128, -0.0);
	9573	try testArgs(u32, f128, 0.0);
	9574	try testArgs(u32, f128, 1e-1);
	9575	try testArgs(u32, f128, 1e0);
	9576	try testArgs(u32, f128, 1e1);
	9577	try testArgs(u32, f128, 1e2);
	9578	try testArgs(u32, f128, 1e3);
	9579	try testArgs(u32, f128, 1e4);
	9580	try testArgs(u32, f128, 1e5);
	9581	try testArgs(u32, f128, 1e6);
	9582	try testArgs(u32, f128, 1e7);
	9583	try testArgs(u32, f128, 1e8);
	9584	try testArgs(u32, f128, 1e9);
	9585	try testArgs(u32, f128, next(f128, next(f128, 0x1p32, 0.0), 0.0));
	9586	try testArgs(u32, f128, next(f128, 0x1p32, 0.0));
	9587
	9588	try testArgs(i64, f128, -0x0.8p64);
	9589	try testArgs(i64, f128, next(f128, -0x0.8p64, -0.0));
	9590	try testArgs(i64, f128, next(f128, next(f128, -0x0.8p64, -0.0), -0.0));
	9591	try testArgs(i64, f128, -1e18);
	9592	try testArgs(i64, f128, -1e16);
	9593	try testArgs(i64, f128, -1e14);
	9594	try testArgs(i64, f128, -1e12);
	9595	try testArgs(i64, f128, -1e10);
	9596	try testArgs(i64, f128, -1e8);
	9597	try testArgs(i64, f128, -1e6);
	9598	try testArgs(i64, f128, -1e4);
	9599	try testArgs(i64, f128, -1e2);
	9600	try testArgs(i64, f128, -1e0);
	9601	try testArgs(i64, f128, -1e-1);
	9602	try testArgs(i64, f128, -0.0);
	9603	try testArgs(i64, f128, 0.0);
	9604	try testArgs(i64, f128, 1e-1);
	9605	try testArgs(i64, f128, 1e0);
	9606	try testArgs(i64, f128, 1e2);
	9607	try testArgs(i64, f128, 1e4);
	9608	try testArgs(i64, f128, 1e6);
	9609	try testArgs(i64, f128, 1e8);
	9610	try testArgs(i64, f128, 1e10);
	9611	try testArgs(i64, f128, 1e11);
	9612	try testArgs(i64, f128, 1e12);
	9613	try testArgs(i64, f128, 1e13);
	9614	try testArgs(i64, f128, 1e14);
	9615	try testArgs(i64, f128, 1e15);
	9616	try testArgs(i64, f128, 1e16);
	9617	try testArgs(i64, f128, 1e17);
	9618	try testArgs(i64, f128, 1e18);
	9619	try testArgs(i64, f128, next(f128, next(f128, 0x0.8p64, 0.0), 0.0));
	9620	try testArgs(i64, f128, next(f128, 0x0.8p64, 0.0));
	9621
	9622	try testArgs(u64, f128, -0.0);
	9623	try testArgs(u64, f128, 0.0);
	9624	try testArgs(u64, f128, 1e-1);
	9625	try testArgs(u64, f128, 1e0);
	9626	try testArgs(u64, f128, 1e2);
	9627	try testArgs(u64, f128, 1e4);
	9628	try testArgs(u64, f128, 1e6);
	9629	try testArgs(u64, f128, 1e8);
	9630	try testArgs(u64, f128, 1e10);
	9631	try testArgs(u64, f128, 1e12);
	9632	try testArgs(u64, f128, 1e14);
	9633	try testArgs(u64, f128, 1e16);
	9634	try testArgs(u64, f128, 1e18);
	9635	try testArgs(u64, f128, next(f128, next(f128, 0x1p64, 0.0), 0.0));
	9636	try testArgs(u64, f128, next(f128, 0x1p64, 0.0));
	9637
	9638	try testArgs(i128, f128, -0x0.8p128);
	9639	try testArgs(i128, f128, next(f128, -0x0.8p128, -0.0));
	9640	try testArgs(i128, f128, next(f128, next(f128, -0x0.8p128, -0.0), -0.0));
	9641	try testArgs(i128, f128, -1e38);
	9642	try testArgs(i128, f128, -1e34);
	9643	try testArgs(i128, f128, -1e30);
	9644	try testArgs(i128, f128, -1e26);
	9645	try testArgs(i128, f128, -1e22);
	9646	try testArgs(i128, f128, -1e18);
	9647	try testArgs(i128, f128, -1e14);
	9648	try testArgs(i128, f128, -1e10);
	9649	try testArgs(i128, f128, -1e6);
	9650	try testArgs(i128, f128, -1e2);
	9651	try testArgs(i128, f128, -1e0);
	9652	try testArgs(i128, f128, -1e-1);
	9653	try testArgs(i128, f128, -0.0);
	9654	try testArgs(i128, f128, 0.0);
	9655	try testArgs(i128, f128, 1e-1);
	9656	try testArgs(i128, f128, 1e0);
	9657	try testArgs(i128, f128, 1e2);
	9658	try testArgs(i128, f128, 1e6);
	9659	try testArgs(i128, f128, 1e10);
	9660	try testArgs(i128, f128, 1e14);
	9661	try testArgs(i128, f128, 1e18);
	9662	try testArgs(i128, f128, 1e22);
	9663	try testArgs(i128, f128, 1e26);
	9664	try testArgs(i128, f128, 1e30);
	9665	try testArgs(i128, f128, 1e34);
	9666	try testArgs(i128, f128, 1e38);
	9667	try testArgs(i128, f128, next(f128, next(f128, 0x0.8p128, 0.0), 0.0));
	9668	try testArgs(i128, f128, next(f128, 0x0.8p128, 0.0));
	9669
	9670	try testArgs(u128, f128, -0.0);
	9671	try testArgs(u128, f128, 0.0);
	9672	try testArgs(u128, f128, 1e-1);
	9673	try testArgs(u128, f128, 1e0);
	9674	try testArgs(u128, f128, 1e2);
	9675	try testArgs(u128, f128, 1e6);
	9676	try testArgs(u128, f128, 1e10);
	9677	try testArgs(u128, f128, 1e14);
	9678	try testArgs(u128, f128, 1e18);
	9679	try testArgs(u128, f128, 1e22);
	9680	try testArgs(u128, f128, 1e26);
	9681	try testArgs(u128, f128, 1e30);
	9682	try testArgs(u128, f128, 1e34);
	9683	try testArgs(u128, f128, 1e38);
	9684	try testArgs(u128, f128, next(f128, next(f128, 0x1p128, 0.0), 0.0));
	9685	try testArgs(u128, f128, next(f128, 0x1p128, 0.0));
	9686
	9687	try testArgs(i256, f128, -0x0.8p256);
	9688	try testArgs(i256, f128, next(f128, -0x0.8p256, -0.0));
	9689	try testArgs(i256, f128, next(f128, next(f128, -0x0.8p256, -0.0), -0.0));
	9690	try testArgs(i256, f128, -1e76);
	9691	try testArgs(i256, f128, -1e69);
	9692	try testArgs(i256, f128, -1e62);
	9693	try testArgs(i256, f128, -1e55);
	9694	try testArgs(i256, f128, -1e48);
	9695	try testArgs(i256, f128, -1e41);
	9696	try testArgs(i256, f128, -1e34);
	9697	try testArgs(i256, f128, -1e27);
	9698	try testArgs(i256, f128, -1e20);
	9699	try testArgs(i256, f128, -1e13);
	9700	try testArgs(i256, f128, -1e6);
	9701	try testArgs(i256, f128, -1e0);
	9702	try testArgs(i256, f128, -1e-1);
	9703	try testArgs(i256, f128, -0.0);
	9704	try testArgs(i256, f128, 0.0);
	9705	try testArgs(i256, f128, 1e-1);
	9706	try testArgs(i256, f128, 1e0);
	9707	try testArgs(i256, f128, 1e6);
	9708	try testArgs(i256, f128, 1e13);
	9709	try testArgs(i256, f128, 1e20);
	9710	try testArgs(i256, f128, 1e27);
	9711	try testArgs(i256, f128, 1e34);
	9712	try testArgs(i256, f128, 1e41);
	9713	try testArgs(i256, f128, 1e48);
	9714	try testArgs(i256, f128, 1e55);
	9715	try testArgs(i256, f128, 1e62);
	9716	try testArgs(i256, f128, 1e69);
	9717	try testArgs(i256, f128, 1e76);
	9718	try testArgs(i256, f128, next(f128, next(f128, 0x0.8p256, 0.0), 0.0));
	9719	try testArgs(i256, f128, next(f128, 0x0.8p256, 0.0));
	9720
	9721	try testArgs(u256, f128, -0.0);
	9722	try testArgs(u256, f128, 0.0);
	9723	try testArgs(u256, f128, 1e-1);
	9724	try testArgs(u256, f128, 1e0);
	9725	try testArgs(u256, f128, 1e7);
	9726	try testArgs(u256, f128, 1e14);
	9727	try testArgs(u256, f128, 1e21);
	9728	try testArgs(u256, f128, 1e28);
	9729	try testArgs(u256, f128, 1e35);
	9730	try testArgs(u256, f128, 1e42);
	9731	try testArgs(u256, f128, 1e49);
	9732	try testArgs(u256, f128, 1e56);
	9733	try testArgs(u256, f128, 1e63);
	9734	try testArgs(u256, f128, 1e70);
	9735	try testArgs(u256, f128, 1e77);
	9736	try testArgs(u256, f128, next(f128, next(f128, 0x1p256, 0.0), 0.0));
	9737	try testArgs(u256, f128, next(f128, 0x1p256, 0.0));
	9738	}
	9739	fn testFloatsFromInts() !void {
	9740	try testArgs(f16, i8, imin(i8));
	9741	try testArgs(f16, i8, imin(i8) + 1);
	9742	try testArgs(f16, i8, -1e2);
	9743	try testArgs(f16, i8, -1e1);
	9744	try testArgs(f16, i8, -1e0);
	9745	try testArgs(f16, i8, 0);
	9746	try testArgs(f16, i8, 1e0);
	9747	try testArgs(f16, i8, 1e1);
	9748	try testArgs(f16, i8, 1e2);
	9749	try testArgs(f16, i8, imax(i8) - 1);
	9750	try testArgs(f16, i8, imax(i8));
	9751
	9752	try testArgs(f16, u8, 0);
	9753	try testArgs(f16, u8, 1e0);
	9754	try testArgs(f16, u8, 1e1);
	9755	try testArgs(f16, u8, 1e2);
	9756	try testArgs(f16, u8, imax(u8) - 1);
	9757	try testArgs(f16, u8, imax(u8));
	9758
	9759	try testArgs(f16, i16, imin(i16));
	9760	try testArgs(f16, i16, imin(i16) + 1);
	9761	try testArgs(f16, i16, -1e4);
	9762	try testArgs(f16, i16, -1e3);
	9763	try testArgs(f16, i16, -1e2);
	9764	try testArgs(f16, i16, -1e1);
	9765	try testArgs(f16, i16, -1e0);
	9766	try testArgs(f16, i16, 0);
	9767	try testArgs(f16, i16, 1e0);
	9768	try testArgs(f16, i16, 1e1);
	9769	try testArgs(f16, i16, 1e2);
	9770	try testArgs(f16, i16, 1e3);
	9771	try testArgs(f16, i16, 1e4);
	9772	try testArgs(f16, i16, imax(i16) - 1);
	9773	try testArgs(f16, i16, imax(i16));
	9774
	9775	try testArgs(f16, u16, 0);
	9776	try testArgs(f16, u16, 1e0);
	9777	try testArgs(f16, u16, 1e1);
	9778	try testArgs(f16, u16, 1e2);
	9779	try testArgs(f16, u16, 1e3);
	9780	try testArgs(f16, u16, 1e4);
	9781	try testArgs(f16, u16, imax(u16) - 1);
	9782	try testArgs(f16, u16, imax(u16));
	9783
	9784	try testArgs(f16, i32, imin(i32));
	9785	try testArgs(f16, i32, imin(i32) + 1);
	9786	try testArgs(f16, i32, -1e9);
	9787	try testArgs(f16, i32, -1e8);
	9788	try testArgs(f16, i32, -1e7);
	9789	try testArgs(f16, i32, -1e6);
	9790	try testArgs(f16, i32, -1e5);
	9791	try testArgs(f16, i32, -1e4);
	9792	try testArgs(f16, i32, -1e3);
	9793	try testArgs(f16, i32, -1e2);
	9794	try testArgs(f16, i32, -1e1);
	9795	try testArgs(f16, i32, -1e0);
	9796	try testArgs(f16, i32, 0);
	9797	try testArgs(f16, i32, 1e0);
	9798	try testArgs(f16, i32, 1e1);
	9799	try testArgs(f16, i32, 1e2);
	9800	try testArgs(f16, i32, 1e3);
	9801	try testArgs(f16, i32, 1e4);
	9802	try testArgs(f16, i32, 1e5);
	9803	try testArgs(f16, i32, 1e6);
	9804	try testArgs(f16, i32, 1e7);
	9805	try testArgs(f16, i32, 1e8);
	9806	try testArgs(f16, i32, 1e9);
	9807	try testArgs(f16, i32, imax(i32) - 1);
	9808	try testArgs(f16, i32, imax(i32));
	9809
	9810	try testArgs(f16, u32, 0);
	9811	try testArgs(f16, u32, 1e0);
	9812	try testArgs(f16, u32, 1e1);
	9813	try testArgs(f16, u32, 1e2);
	9814	try testArgs(f16, u32, 1e3);
	9815	try testArgs(f16, u32, 1e4);
	9816	try testArgs(f16, u32, 1e5);
	9817	try testArgs(f16, u32, 1e6);
	9818	try testArgs(f16, u32, 1e7);
	9819	try testArgs(f16, u32, 1e8);
	9820	try testArgs(f16, u32, 1e9);
	9821	try testArgs(f16, u32, imax(u32) - 1);
	9822	try testArgs(f16, u32, imax(u32));
	9823
	9824	try testArgs(f16, i64, imin(i64));
	9825	try testArgs(f16, i64, imin(i64) + 1);
	9826	try testArgs(f16, i64, -1e18);
	9827	try testArgs(f16, i64, -1e16);
	9828	try testArgs(f16, i64, -1e14);
	9829	try testArgs(f16, i64, -1e12);
	9830	try testArgs(f16, i64, -1e10);
	9831	try testArgs(f16, i64, -1e8);
	9832	try testArgs(f16, i64, -1e6);
	9833	try testArgs(f16, i64, -1e4);
	9834	try testArgs(f16, i64, -1e2);
	9835	try testArgs(f16, i64, -1e0);
	9836	try testArgs(f16, i64, 0);
	9837	try testArgs(f16, i64, 1e0);
	9838	try testArgs(f16, i64, 1e2);
	9839	try testArgs(f16, i64, 1e4);
	9840	try testArgs(f16, i64, 1e6);
	9841	try testArgs(f16, i64, 1e8);
	9842	try testArgs(f16, i64, 1e10);
	9843	try testArgs(f16, i64, 1e12);
	9844	try testArgs(f16, i64, 1e14);
	9845	try testArgs(f16, i64, 1e16);
	9846	try testArgs(f16, i64, 1e18);
	9847	try testArgs(f16, i64, imax(i64) - 1);
	9848	try testArgs(f16, i64, imax(i64));
	9849
	9850	try testArgs(f16, u64, 0);
	9851	try testArgs(f16, u64, 1e0);
	9852	try testArgs(f16, u64, 1e2);
	9853	try testArgs(f16, u64, 1e4);
	9854	try testArgs(f16, u64, 1e6);
	9855	try testArgs(f16, u64, 1e8);
	9856	try testArgs(f16, u64, 1e10);
	9857	try testArgs(f16, u64, 1e12);
	9858	try testArgs(f16, u64, 1e14);
	9859	try testArgs(f16, u64, 1e16);
	9860	try testArgs(f16, u64, 1e18);
	9861	try testArgs(f16, u64, imax(u64) - 1);
	9862	try testArgs(f16, u64, imax(u64));
	9863
	9864	try testArgs(f16, i128, imin(i128));
	9865	try testArgs(f16, i128, imin(i128) + 1);
	9866	try testArgs(f16, i128, -1e38);
	9867	try testArgs(f16, i128, -1e34);
	9868	try testArgs(f16, i128, -1e30);
	9869	try testArgs(f16, i128, -1e26);
	9870	try testArgs(f16, i128, -1e22);
	9871	try testArgs(f16, i128, -1e18);
	9872	try testArgs(f16, i128, -1e14);
	9873	try testArgs(f16, i128, -1e10);
	9874	try testArgs(f16, i128, -1e6);
	9875	try testArgs(f16, i128, -1e2);
	9876	try testArgs(f16, i128, -1e0);
	9877	try testArgs(f16, i128, 0);
	9878	try testArgs(f16, i128, 1e0);
	9879	try testArgs(f16, i128, 1e2);
	9880	try testArgs(f16, i128, 1e6);
	9881	try testArgs(f16, i128, 1e10);
	9882	try testArgs(f16, i128, 1e14);
	9883	try testArgs(f16, i128, 1e18);
	9884	try testArgs(f16, i128, 1e22);
	9885	try testArgs(f16, i128, 1e26);
	9886	try testArgs(f16, i128, 1e30);
	9887	try testArgs(f16, i128, 1e34);
	9888	try testArgs(f16, i128, 1e38);
	9889	try testArgs(f16, i128, imax(i128) - 1);
	9890	try testArgs(f16, i128, imax(i128));
	9891
	9892	try testArgs(f16, u128, 0);
	9893	try testArgs(f16, u128, 1e0);
	9894	try testArgs(f16, u128, 1e2);
	9895	try testArgs(f16, u128, 1e6);
	9896	try testArgs(f16, u128, 1e10);
	9897	try testArgs(f16, u128, 1e14);
	9898	try testArgs(f16, u128, 1e18);
	9899	try testArgs(f16, u128, 1e22);
	9900	try testArgs(f16, u128, 1e26);
	9901	try testArgs(f16, u128, 1e30);
	9902	try testArgs(f16, u128, 1e34);
	9903	try testArgs(f16, u128, 1e38);
	9904	try testArgs(f16, u128, imax(u128) - 1);
	9905	try testArgs(f16, u128, imax(u128));
	9906
	9907	try testArgs(f16, i256, imin(i256));
	9908	try testArgs(f16, i256, imin(i256) + 1);
	9909	try testArgs(f16, i256, -1e76);
	9910	try testArgs(f16, i256, -1e69);
	9911	try testArgs(f16, i256, -1e62);
	9912	try testArgs(f16, i256, -1e55);
	9913	try testArgs(f16, i256, -1e48);
	9914	try testArgs(f16, i256, -1e41);
	9915	try testArgs(f16, i256, -1e34);
	9916	try testArgs(f16, i256, -1e27);
	9917	try testArgs(f16, i256, -1e20);
	9918	try testArgs(f16, i256, -1e13);
	9919	try testArgs(f16, i256, -1e6);
	9920	try testArgs(f16, i256, -1e0);
	9921	try testArgs(f16, i256, 0);
	9922	try testArgs(f16, i256, 1e0);
	9923	try testArgs(f16, i256, 1e6);
	9924	try testArgs(f16, i256, 1e13);
	9925	try testArgs(f16, i256, 1e20);
	9926	try testArgs(f16, i256, 1e27);
	9927	try testArgs(f16, i256, 1e34);
	9928	try testArgs(f16, i256, 1e41);
	9929	try testArgs(f16, i256, 1e48);
	9930	try testArgs(f16, i256, 1e55);
	9931	try testArgs(f16, i256, 1e62);
	9932	try testArgs(f16, i256, 1e69);
	9933	try testArgs(f16, i256, 1e76);
	9934	try testArgs(f16, i256, imax(i256) - 1);
	9935	try testArgs(f16, i256, imax(i256));
	9936
	9937	try testArgs(f16, u256, 0);
	9938	try testArgs(f16, u256, 1e0);
	9939	try testArgs(f16, u256, 1e7);
	9940	try testArgs(f16, u256, 1e14);
	9941	try testArgs(f16, u256, 1e21);
	9942	try testArgs(f16, u256, 1e28);
	9943	try testArgs(f16, u256, 1e35);
	9944	try testArgs(f16, u256, 1e42);
	9945	try testArgs(f16, u256, 1e49);
	9946	try testArgs(f16, u256, 1e56);
	9947	try testArgs(f16, u256, 1e63);
	9948	try testArgs(f16, u256, 1e70);
	9949	try testArgs(f16, u256, 1e77);
	9950	try testArgs(f16, u256, imax(u256) - 1);
	9951	try testArgs(f16, u256, imax(u256));
	9952
	9953	try testArgs(f32, i8, imin(i8));
	9954	try testArgs(f32, i8, imin(i8) + 1);
	9955	try testArgs(f32, i8, -1e2);
	9956	try testArgs(f32, i8, -1e1);
	9957	try testArgs(f32, i8, -1e0);
	9958	try testArgs(f32, i8, 0);
	9959	try testArgs(f32, i8, 1e0);
	9960	try testArgs(f32, i8, 1e1);
	9961	try testArgs(f32, i8, 1e2);
	9962	try testArgs(f32, i8, imax(i8) - 1);
	9963	try testArgs(f32, i8, imax(i8));
	9964
	9965	try testArgs(f32, u8, 0);
	9966	try testArgs(f32, u8, 1e0);
	9967	try testArgs(f32, u8, 1e1);
	9968	try testArgs(f32, u8, 1e2);
	9969	try testArgs(f32, u8, imax(u8) - 1);
	9970	try testArgs(f32, u8, imax(u8));
	9971
	9972	try testArgs(f32, i16, imin(i16));
	9973	try testArgs(f32, i16, imin(i16) + 1);
	9974	try testArgs(f32, i16, -1e4);
	9975	try testArgs(f32, i16, -1e3);
	9976	try testArgs(f32, i16, -1e2);
	9977	try testArgs(f32, i16, -1e1);
	9978	try testArgs(f32, i16, -1e0);
	9979	try testArgs(f32, i16, 0);
	9980	try testArgs(f32, i16, 1e0);
	9981	try testArgs(f32, i16, 1e1);
	9982	try testArgs(f32, i16, 1e2);
	9983	try testArgs(f32, i16, 1e3);
	9984	try testArgs(f32, i16, 1e4);
	9985	try testArgs(f32, i16, imax(i16) - 1);
	9986	try testArgs(f32, i16, imax(i16));
	9987
	9988	try testArgs(f32, u16, 0);
	9989	try testArgs(f32, u16, 1e0);
	9990	try testArgs(f32, u16, 1e1);
	9991	try testArgs(f32, u16, 1e2);
	9992	try testArgs(f32, u16, 1e3);
	9993	try testArgs(f32, u16, 1e4);
	9994	try testArgs(f32, u16, imax(u16) - 1);
	9995	try testArgs(f32, u16, imax(u16));
	9996
	9997	try testArgs(f32, i32, imin(i32));
	9998	try testArgs(f32, i32, imin(i32) + 1);
	9999	try testArgs(f32, i32, -1e9);
	10000	try testArgs(f32, i32, -1e8);
	10001	try testArgs(f32, i32, -1e7);
	10002	try testArgs(f32, i32, -1e6);
	10003	try testArgs(f32, i32, -1e5);
	10004	try testArgs(f32, i32, -1e4);
	10005	try testArgs(f32, i32, -1e3);
	10006	try testArgs(f32, i32, -1e2);
	10007	try testArgs(f32, i32, -1e1);
	10008	try testArgs(f32, i32, -1e0);
	10009	try testArgs(f32, i32, 0);
	10010	try testArgs(f32, i32, 1e0);
	10011	try testArgs(f32, i32, 1e1);
	10012	try testArgs(f32, i32, 1e2);
	10013	try testArgs(f32, i32, 1e3);
	10014	try testArgs(f32, i32, 1e4);
	10015	try testArgs(f32, i32, 1e5);
	10016	try testArgs(f32, i32, 1e6);
	10017	try testArgs(f32, i32, 1e7);
	10018	try testArgs(f32, i32, 1e8);
	10019	try testArgs(f32, i32, 1e9);
	10020	try testArgs(f32, i32, imax(i32) - 1);
	10021	try testArgs(f32, i32, imax(i32));
	10022
	10023	try testArgs(f32, u32, 0);
	10024	try testArgs(f32, u32, 1e0);
	10025	try testArgs(f32, u32, 1e1);
	10026	try testArgs(f32, u32, 1e2);
	10027	try testArgs(f32, u32, 1e3);
	10028	try testArgs(f32, u32, 1e4);
	10029	try testArgs(f32, u32, 1e5);
	10030	try testArgs(f32, u32, 1e6);
	10031	try testArgs(f32, u32, 1e7);
	10032	try testArgs(f32, u32, 1e8);
	10033	try testArgs(f32, u32, 1e9);
	10034	try testArgs(f32, u32, imax(u32) - 1);
	10035	try testArgs(f32, u32, imax(u32));
	10036
	10037	try testArgs(f32, i64, imin(i64));
	10038	try testArgs(f32, i64, imin(i64) + 1);
	10039	try testArgs(f32, i64, -1e18);
	10040	try testArgs(f32, i64, -1e16);
	10041	try testArgs(f32, i64, -1e14);
	10042	try testArgs(f32, i64, -1e12);
	10043	try testArgs(f32, i64, -1e10);
	10044	try testArgs(f32, i64, -1e8);
	10045	try testArgs(f32, i64, -1e6);
	10046	try testArgs(f32, i64, -1e4);
	10047	try testArgs(f32, i64, -1e2);
	10048	try testArgs(f32, i64, -1e0);
	10049	try testArgs(f32, i64, 0);
	10050	try testArgs(f32, i64, 1e0);
	10051	try testArgs(f32, i64, 1e2);
	10052	try testArgs(f32, i64, 1e4);
	10053	try testArgs(f32, i64, 1e6);
	10054	try testArgs(f32, i64, 1e8);
	10055	try testArgs(f32, i64, 1e10);
	10056	try testArgs(f32, i64, 1e12);
	10057	try testArgs(f32, i64, 1e14);
	10058	try testArgs(f32, i64, 1e16);
	10059	try testArgs(f32, i64, 1e18);
	10060	try testArgs(f32, i64, imax(i64) - 1);
	10061	try testArgs(f32, i64, imax(i64));
	10062
	10063	try testArgs(f32, u64, 0);
	10064	try testArgs(f32, u64, 1e0);
	10065	try testArgs(f32, u64, 1e2);
	10066	try testArgs(f32, u64, 1e4);
	10067	try testArgs(f32, u64, 1e6);
	10068	try testArgs(f32, u64, 1e8);
	10069	try testArgs(f32, u64, 1e10);
	10070	try testArgs(f32, u64, 1e12);
	10071	try testArgs(f32, u64, 1e14);
	10072	try testArgs(f32, u64, 1e16);
	10073	try testArgs(f32, u64, 1e18);
	10074	try testArgs(f32, u64, imax(u64) - 1);
	10075	try testArgs(f32, u64, imax(u64));
	10076
	10077	try testArgs(f32, i128, imin(i128));
	10078	try testArgs(f32, i128, imin(i128) + 1);
	10079	try testArgs(f32, i128, -1e38);
	10080	try testArgs(f32, i128, -1e34);
	10081	try testArgs(f32, i128, -1e30);
	10082	try testArgs(f32, i128, -1e26);
	10083	try testArgs(f32, i128, -1e22);
	10084	try testArgs(f32, i128, -1e18);
	10085	try testArgs(f32, i128, -1e14);
	10086	try testArgs(f32, i128, -1e10);
	10087	try testArgs(f32, i128, -1e6);
	10088	try testArgs(f32, i128, -1e2);
	10089	try testArgs(f32, i128, -1e0);
	10090	try testArgs(f32, i128, 0);
	10091	try testArgs(f32, i128, 1e0);
	10092	try testArgs(f32, i128, 1e2);
	10093	try testArgs(f32, i128, 1e6);
	10094	try testArgs(f32, i128, 1e10);
	10095	try testArgs(f32, i128, 1e14);
	10096	try testArgs(f32, i128, 1e18);
	10097	try testArgs(f32, i128, 1e22);
	10098	try testArgs(f32, i128, 1e26);
	10099	try testArgs(f32, i128, 1e30);
	10100	try testArgs(f32, i128, 1e34);
	10101	try testArgs(f32, i128, 1e38);
	10102	try testArgs(f32, i128, imax(i128) - 1);
	10103	try testArgs(f32, i128, imax(i128));
	10104
	10105	try testArgs(f32, u128, 0);
	10106	try testArgs(f32, u128, 1e0);
	10107	try testArgs(f32, u128, 1e2);
	10108	try testArgs(f32, u128, 1e6);
	10109	try testArgs(f32, u128, 1e10);
	10110	try testArgs(f32, u128, 1e14);
	10111	try testArgs(f32, u128, 1e18);
	10112	try testArgs(f32, u128, 1e22);
	10113	try testArgs(f32, u128, 1e26);
	10114	try testArgs(f32, u128, 1e30);
	10115	try testArgs(f32, u128, 1e34);
	10116	try testArgs(f32, u128, 1e38);
	10117	try testArgs(f32, u128, imax(u128) - 1);
	10118	try testArgs(f32, u128, imax(u128));
	10119
	10120	try testArgs(f32, i256, imin(i256));
	10121	try testArgs(f32, i256, imin(i256) + 1);
	10122	try testArgs(f32, i256, -1e76);
	10123	try testArgs(f32, i256, -1e69);
	10124	try testArgs(f32, i256, -1e62);
	10125	try testArgs(f32, i256, -1e55);
	10126	try testArgs(f32, i256, -1e48);
	10127	try testArgs(f32, i256, -1e41);
	10128	try testArgs(f32, i256, -1e34);
	10129	try testArgs(f32, i256, -1e27);
	10130	try testArgs(f32, i256, -1e20);
	10131	try testArgs(f32, i256, -1e13);
	10132	try testArgs(f32, i256, -1e6);
	10133	try testArgs(f32, i256, -1e0);
	10134	try testArgs(f32, i256, 0);
	10135	try testArgs(f32, i256, 1e0);
	10136	try testArgs(f32, i256, 1e6);
	10137	try testArgs(f32, i256, 1e13);
	10138	try testArgs(f32, i256, 1e20);
	10139	try testArgs(f32, i256, 1e27);
	10140	try testArgs(f32, i256, 1e34);
	10141	try testArgs(f32, i256, 1e41);
	10142	try testArgs(f32, i256, 1e48);
	10143	try testArgs(f32, i256, 1e55);
	10144	try testArgs(f32, i256, 1e62);
	10145	try testArgs(f32, i256, 1e69);
	10146	try testArgs(f32, i256, 1e76);
	10147	try testArgs(f32, i256, imax(i256) - 1);
	10148	try testArgs(f32, i256, imax(i256));
	10149
	10150	try testArgs(f32, u256, 0);
	10151	try testArgs(f32, u256, 1e0);
	10152	try testArgs(f32, u256, 1e7);
	10153	try testArgs(f32, u256, 1e14);
	10154	try testArgs(f32, u256, 1e21);
	10155	try testArgs(f32, u256, 1e28);
	10156	try testArgs(f32, u256, 1e35);
	10157	try testArgs(f32, u256, 1e42);
	10158	try testArgs(f32, u256, 1e49);
	10159	try testArgs(f32, u256, 1e56);
	10160	try testArgs(f32, u256, 1e63);
	10161	try testArgs(f32, u256, 1e70);
	10162	try testArgs(f32, u256, 1e77);
	10163	try testArgs(f32, u256, imax(u256) - 1);
	10164	try testArgs(f32, u256, imax(u256));
	10165
	10166	try testArgs(f64, i8, imin(i8));
	10167	try testArgs(f64, i8, imin(i8) + 1);
	10168	try testArgs(f64, i8, -1e2);
	10169	try testArgs(f64, i8, -1e1);
	10170	try testArgs(f64, i8, -1e0);
	10171	try testArgs(f64, i8, 0);
	10172	try testArgs(f64, i8, 1e0);
	10173	try testArgs(f64, i8, 1e1);
	10174	try testArgs(f64, i8, 1e2);
	10175	try testArgs(f64, i8, imax(i8) - 1);
	10176	try testArgs(f64, i8, imax(i8));
	10177
	10178	try testArgs(f64, u8, 0);
	10179	try testArgs(f64, u8, 1e0);
	10180	try testArgs(f64, u8, 1e1);
	10181	try testArgs(f64, u8, 1e2);
	10182	try testArgs(f64, u8, imax(u8) - 1);
	10183	try testArgs(f64, u8, imax(u8));
	10184
	10185	try testArgs(f64, i16, imin(i16));
	10186	try testArgs(f64, i16, imin(i16) + 1);
	10187	try testArgs(f64, i16, -1e4);
	10188	try testArgs(f64, i16, -1e3);
	10189	try testArgs(f64, i16, -1e2);
	10190	try testArgs(f64, i16, -1e1);
	10191	try testArgs(f64, i16, -1e0);
	10192	try testArgs(f64, i16, 0);
	10193	try testArgs(f64, i16, 1e0);
	10194	try testArgs(f64, i16, 1e1);
	10195	try testArgs(f64, i16, 1e2);
	10196	try testArgs(f64, i16, 1e3);
	10197	try testArgs(f64, i16, 1e4);
	10198	try testArgs(f64, i16, imax(i16) - 1);
	10199	try testArgs(f64, i16, imax(i16));
	10200
	10201	try testArgs(f64, u16, 0);
	10202	try testArgs(f64, u16, 1e0);
	10203	try testArgs(f64, u16, 1e1);
	10204	try testArgs(f64, u16, 1e2);
	10205	try testArgs(f64, u16, 1e3);
	10206	try testArgs(f64, u16, 1e4);
	10207	try testArgs(f64, u16, imax(u16) - 1);
	10208	try testArgs(f64, u16, imax(u16));
	10209
	10210	try testArgs(f64, i32, imin(i32));
	10211	try testArgs(f64, i32, imin(i32) + 1);
	10212	try testArgs(f64, i32, -1e9);
	10213	try testArgs(f64, i32, -1e8);
	10214	try testArgs(f64, i32, -1e7);
	10215	try testArgs(f64, i32, -1e6);
	10216	try testArgs(f64, i32, -1e5);
	10217	try testArgs(f64, i32, -1e4);
	10218	try testArgs(f64, i32, -1e3);
	10219	try testArgs(f64, i32, -1e2);
	10220	try testArgs(f64, i32, -1e1);
	10221	try testArgs(f64, i32, -1e0);
	10222	try testArgs(f64, i32, 0);
	10223	try testArgs(f64, i32, 1e0);
	10224	try testArgs(f64, i32, 1e1);
	10225	try testArgs(f64, i32, 1e2);
	10226	try testArgs(f64, i32, 1e3);
	10227	try testArgs(f64, i32, 1e4);
	10228	try testArgs(f64, i32, 1e5);
	10229	try testArgs(f64, i32, 1e6);
	10230	try testArgs(f64, i32, 1e7);
	10231	try testArgs(f64, i32, 1e8);
	10232	try testArgs(f64, i32, 1e9);
	10233	try testArgs(f64, i32, imax(i32) - 1);
	10234	try testArgs(f64, i32, imax(i32));
	10235
	10236	try testArgs(f64, u32, 0);
	10237	try testArgs(f64, u32, 1e0);
	10238	try testArgs(f64, u32, 1e1);
	10239	try testArgs(f64, u32, 1e2);
	10240	try testArgs(f64, u32, 1e3);
	10241	try testArgs(f64, u32, 1e4);
	10242	try testArgs(f64, u32, 1e5);
	10243	try testArgs(f64, u32, 1e6);
	10244	try testArgs(f64, u32, 1e7);
	10245	try testArgs(f64, u32, 1e8);
	10246	try testArgs(f64, u32, 1e9);
	10247	try testArgs(f64, u32, imax(u32) - 1);
	10248	try testArgs(f64, u32, imax(u32));
	10249
	10250	try testArgs(f64, i64, imin(i64));
	10251	try testArgs(f64, i64, imin(i64) + 1);
	10252	try testArgs(f64, i64, -1e18);
	10253	try testArgs(f64, i64, -1e16);
	10254	try testArgs(f64, i64, -1e14);
	10255	try testArgs(f64, i64, -1e12);
	10256	try testArgs(f64, i64, -1e10);
	10257	try testArgs(f64, i64, -1e8);
	10258	try testArgs(f64, i64, -1e6);
	10259	try testArgs(f64, i64, -1e4);
	10260	try testArgs(f64, i64, -1e2);
	10261	try testArgs(f64, i64, -1e0);
	10262	try testArgs(f64, i64, 0);
	10263	try testArgs(f64, i64, 1e0);
	10264	try testArgs(f64, i64, 1e2);
	10265	try testArgs(f64, i64, 1e4);
	10266	try testArgs(f64, i64, 1e6);
	10267	try testArgs(f64, i64, 1e8);
	10268	try testArgs(f64, i64, 1e10);
	10269	try testArgs(f64, i64, 1e12);
	10270	try testArgs(f64, i64, 1e14);
	10271	try testArgs(f64, i64, 1e16);
	10272	try testArgs(f64, i64, 1e18);
	10273	try testArgs(f64, i64, imax(i64) - 1);
	10274	try testArgs(f64, i64, imax(i64));
	10275
	10276	try testArgs(f64, u64, 0);
	10277	try testArgs(f64, u64, 1e0);
	10278	try testArgs(f64, u64, 1e2);
	10279	try testArgs(f64, u64, 1e4);
	10280	try testArgs(f64, u64, 1e6);
	10281	try testArgs(f64, u64, 1e8);
	10282	try testArgs(f64, u64, 1e10);
	10283	try testArgs(f64, u64, 1e12);
	10284	try testArgs(f64, u64, 1e14);
	10285	try testArgs(f64, u64, 1e16);
	10286	try testArgs(f64, u64, 1e18);
	10287	try testArgs(f64, u64, imax(u64) - 1);
	10288	try testArgs(f64, u64, imax(u64));
	10289
	10290	try testArgs(f64, i128, imin(i128));
	10291	try testArgs(f64, i128, imin(i128) + 1);
	10292	try testArgs(f64, i128, -1e38);
	10293	try testArgs(f64, i128, -1e34);
	10294	try testArgs(f64, i128, -1e30);
	10295	try testArgs(f64, i128, -1e26);
	10296	try testArgs(f64, i128, -1e22);
	10297	try testArgs(f64, i128, -1e18);
	10298	try testArgs(f64, i128, -1e14);
	10299	try testArgs(f64, i128, -1e10);
	10300	try testArgs(f64, i128, -1e6);
	10301	try testArgs(f64, i128, -1e2);
	10302	try testArgs(f64, i128, -1e0);
	10303	try testArgs(f64, i128, 0);
	10304	try testArgs(f64, i128, 1e0);
	10305	try testArgs(f64, i128, 1e2);
	10306	try testArgs(f64, i128, 1e6);
	10307	try testArgs(f64, i128, 1e10);
	10308	try testArgs(f64, i128, 1e14);
	10309	try testArgs(f64, i128, 1e18);
	10310	try testArgs(f64, i128, 1e22);
	10311	try testArgs(f64, i128, 1e26);
	10312	try testArgs(f64, i128, 1e30);
	10313	try testArgs(f64, i128, 1e34);
	10314	try testArgs(f64, i128, 1e38);
	10315	try testArgs(f64, i128, imax(i128) - 1);
	10316	try testArgs(f64, i128, imax(i128));
	10317
	10318	try testArgs(f64, u128, 0);
	10319	try testArgs(f64, u128, 1e0);
	10320	try testArgs(f64, u128, 1e2);
	10321	try testArgs(f64, u128, 1e6);
	10322	try testArgs(f64, u128, 1e10);
	10323	try testArgs(f64, u128, 1e14);
	10324	try testArgs(f64, u128, 1e18);
	10325	try testArgs(f64, u128, 1e22);
	10326	try testArgs(f64, u128, 1e26);
	10327	try testArgs(f64, u128, 1e30);
	10328	try testArgs(f64, u128, 1e34);
	10329	try testArgs(f64, u128, 1e38);
	10330	try testArgs(f64, u128, imax(u128) - 1);
	10331	try testArgs(f64, u128, imax(u128));
	10332
	10333	try testArgs(f64, i256, imin(i256));
	10334	try testArgs(f64, i256, imin(i256) + 1);
	10335	try testArgs(f64, i256, -1e76);
	10336	try testArgs(f64, i256, -1e69);
	10337	try testArgs(f64, i256, -1e62);
	10338	try testArgs(f64, i256, -1e55);
	10339	try testArgs(f64, i256, -1e48);
	10340	try testArgs(f64, i256, -1e41);
	10341	try testArgs(f64, i256, -1e34);
	10342	try testArgs(f64, i256, -1e27);
	10343	try testArgs(f64, i256, -1e20);
	10344	try testArgs(f64, i256, -1e13);
	10345	try testArgs(f64, i256, -1e6);
	10346	try testArgs(f64, i256, -1e0);
	10347	try testArgs(f64, i256, 0);
	10348	try testArgs(f64, i256, 1e0);
	10349	try testArgs(f64, i256, 1e6);
	10350	try testArgs(f64, i256, 1e13);
	10351	try testArgs(f64, i256, 1e20);
	10352	try testArgs(f64, i256, 1e27);
	10353	try testArgs(f64, i256, 1e34);
	10354	try testArgs(f64, i256, 1e41);
	10355	try testArgs(f64, i256, 1e48);
	10356	try testArgs(f64, i256, 1e55);
	10357	try testArgs(f64, i256, 1e62);
	10358	try testArgs(f64, i256, 1e69);
	10359	try testArgs(f64, i256, 1e76);
	10360	try testArgs(f64, i256, imax(i256) - 1);
	10361	try testArgs(f64, i256, imax(i256));
	10362
	10363	try testArgs(f64, u256, 0);
	10364	try testArgs(f64, u256, 1e0);
	10365	try testArgs(f64, u256, 1e7);
	10366	try testArgs(f64, u256, 1e14);
	10367	try testArgs(f64, u256, 1e21);
	10368	try testArgs(f64, u256, 1e28);
	10369	try testArgs(f64, u256, 1e35);
	10370	try testArgs(f64, u256, 1e42);
	10371	try testArgs(f64, u256, 1e49);
	10372	try testArgs(f64, u256, 1e56);
	10373	try testArgs(f64, u256, 1e63);
	10374	try testArgs(f64, u256, 1e70);
	10375	try testArgs(f64, u256, 1e77);
	10376	try testArgs(f64, u256, imax(u256) - 1);
	10377	try testArgs(f64, u256, imax(u256));
	10378
	10379	try testArgs(f80, i8, imin(i8));
	10380	try testArgs(f80, i8, imin(i8) + 1);
	10381	try testArgs(f80, i8, -1e2);
	10382	try testArgs(f80, i8, -1e1);
	10383	try testArgs(f80, i8, -1e0);
	10384	try testArgs(f80, i8, 0);
	10385	try testArgs(f80, i8, 1e0);
	10386	try testArgs(f80, i8, 1e1);
	10387	try testArgs(f80, i8, 1e2);
	10388	try testArgs(f80, i8, imax(i8) - 1);
	10389	try testArgs(f80, i8, imax(i8));
	10390
	10391	try testArgs(f80, u8, 0);
	10392	try testArgs(f80, u8, 1e0);
	10393	try testArgs(f80, u8, 1e1);
	10394	try testArgs(f80, u8, 1e2);
	10395	try testArgs(f80, u8, imax(u8) - 1);
	10396	try testArgs(f80, u8, imax(u8));
	10397
	10398	try testArgs(f80, i16, imin(i16));
	10399	try testArgs(f80, i16, imin(i16) + 1);
	10400	try testArgs(f80, i16, -1e4);
	10401	try testArgs(f80, i16, -1e3);
	10402	try testArgs(f80, i16, -1e2);
	10403	try testArgs(f80, i16, -1e1);
	10404	try testArgs(f80, i16, -1e0);
	10405	try testArgs(f80, i16, 0);
	10406	try testArgs(f80, i16, 1e0);
	10407	try testArgs(f80, i16, 1e1);
	10408	try testArgs(f80, i16, 1e2);
	10409	try testArgs(f80, i16, 1e3);
	10410	try testArgs(f80, i16, 1e4);
	10411	try testArgs(f80, i16, imax(i16) - 1);
	10412	try testArgs(f80, i16, imax(i16));
	10413
	10414	try testArgs(f80, u16, 0);
	10415	try testArgs(f80, u16, 1e0);
	10416	try testArgs(f80, u16, 1e1);
	10417	try testArgs(f80, u16, 1e2);
	10418	try testArgs(f80, u16, 1e3);
	10419	try testArgs(f80, u16, 1e4);
	10420	try testArgs(f80, u16, imax(u16) - 1);
	10421	try testArgs(f80, u16, imax(u16));
	10422
	10423	try testArgs(f80, i32, imin(i32));
	10424	try testArgs(f80, i32, imin(i32) + 1);
	10425	try testArgs(f80, i32, -1e9);
	10426	try testArgs(f80, i32, -1e8);
	10427	try testArgs(f80, i32, -1e7);
	10428	try testArgs(f80, i32, -1e6);
	10429	try testArgs(f80, i32, -1e5);
	10430	try testArgs(f80, i32, -1e4);
	10431	try testArgs(f80, i32, -1e3);
	10432	try testArgs(f80, i32, -1e2);
	10433	try testArgs(f80, i32, -1e1);
	10434	try testArgs(f80, i32, -1e0);
	10435	try testArgs(f80, i32, 0);
	10436	try testArgs(f80, i32, 1e0);
	10437	try testArgs(f80, i32, 1e1);
	10438	try testArgs(f80, i32, 1e2);
	10439	try testArgs(f80, i32, 1e3);
	10440	try testArgs(f80, i32, 1e4);
	10441	try testArgs(f80, i32, 1e5);
	10442	try testArgs(f80, i32, 1e6);
	10443	try testArgs(f80, i32, 1e7);
	10444	try testArgs(f80, i32, 1e8);
	10445	try testArgs(f80, i32, 1e9);
	10446	try testArgs(f80, i32, imax(i32) - 1);
	10447	try testArgs(f80, i32, imax(i32));
	10448
	10449	try testArgs(f80, u32, 0);
	10450	try testArgs(f80, u32, 1e0);
	10451	try testArgs(f80, u32, 1e1);
	10452	try testArgs(f80, u32, 1e2);
	10453	try testArgs(f80, u32, 1e3);
	10454	try testArgs(f80, u32, 1e4);
	10455	try testArgs(f80, u32, 1e5);
	10456	try testArgs(f80, u32, 1e6);
	10457	try testArgs(f80, u32, 1e7);
	10458	try testArgs(f80, u32, 1e8);
	10459	try testArgs(f80, u32, 1e9);
	10460	try testArgs(f80, u32, imax(u32) - 1);
	10461	try testArgs(f80, u32, imax(u32));
	10462
	10463	try testArgs(f80, i64, imin(i64));
	10464	try testArgs(f80, i64, imin(i64) + 1);
	10465	try testArgs(f80, i64, -1e18);
	10466	try testArgs(f80, i64, -1e16);
	10467	try testArgs(f80, i64, -1e14);
	10468	try testArgs(f80, i64, -1e12);
	10469	try testArgs(f80, i64, -1e10);
	10470	try testArgs(f80, i64, -1e8);
	10471	try testArgs(f80, i64, -1e6);
	10472	try testArgs(f80, i64, -1e4);
	10473	try testArgs(f80, i64, -1e2);
	10474	try testArgs(f80, i64, -1e0);
	10475	try testArgs(f80, i64, 0);
	10476	try testArgs(f80, i64, 1e0);
	10477	try testArgs(f80, i64, 1e2);
	10478	try testArgs(f80, i64, 1e4);
	10479	try testArgs(f80, i64, 1e6);
	10480	try testArgs(f80, i64, 1e8);
	10481	try testArgs(f80, i64, 1e10);
	10482	try testArgs(f80, i64, 1e12);
	10483	try testArgs(f80, i64, 1e14);
	10484	try testArgs(f80, i64, 1e16);
	10485	try testArgs(f80, i64, 1e18);
	10486	try testArgs(f80, i64, imax(i64) - 1);
	10487	try testArgs(f80, i64, imax(i64));
	10488
	10489	try testArgs(f80, u64, 0);
	10490	try testArgs(f80, u64, 1e0);
	10491	try testArgs(f80, u64, 1e2);
	10492	try testArgs(f80, u64, 1e4);
	10493	try testArgs(f80, u64, 1e6);
	10494	try testArgs(f80, u64, 1e8);
	10495	try testArgs(f80, u64, 1e10);
	10496	try testArgs(f80, u64, 1e12);
	10497	try testArgs(f80, u64, 1e14);
	10498	try testArgs(f80, u64, 1e16);
	10499	try testArgs(f80, u64, 1e18);
	10500	try testArgs(f80, u64, imax(u64) - 1);
	10501	try testArgs(f80, u64, imax(u64));
	10502
	10503	try testArgs(f80, i128, imin(i128));
	10504	try testArgs(f80, i128, imin(i128) + 1);
	10505	try testArgs(f80, i128, -1e38);
	10506	try testArgs(f80, i128, -1e34);
	10507	try testArgs(f80, i128, -1e30);
	10508	try testArgs(f80, i128, -1e26);
	10509	try testArgs(f80, i128, -1e22);
	10510	try testArgs(f80, i128, -1e18);
	10511	try testArgs(f80, i128, -1e14);
	10512	try testArgs(f80, i128, -1e10);
	10513	try testArgs(f80, i128, -1e6);
	10514	try testArgs(f80, i128, -1e2);
	10515	try testArgs(f80, i128, -1e0);
	10516	try testArgs(f80, i128, 0);
	10517	try testArgs(f80, i128, 1e0);
	10518	try testArgs(f80, i128, 1e2);
	10519	try testArgs(f80, i128, 1e6);
	10520	try testArgs(f80, i128, 1e10);
	10521	try testArgs(f80, i128, 1e14);
	10522	try testArgs(f80, i128, 1e18);
	10523	try testArgs(f80, i128, 1e22);
	10524	try testArgs(f80, i128, 1e26);
	10525	try testArgs(f80, i128, 1e30);
	10526	try testArgs(f80, i128, 1e34);
	10527	try testArgs(f80, i128, 1e38);
	10528	try testArgs(f80, i128, imax(i128) - 1);
	10529	try testArgs(f80, i128, imax(i128));
	10530
	10531	try testArgs(f80, u128, 0);
	10532	try testArgs(f80, u128, 1e0);
	10533	try testArgs(f80, u128, 1e2);
	10534	try testArgs(f80, u128, 1e6);
	10535	try testArgs(f80, u128, 1e10);
	10536	try testArgs(f80, u128, 1e14);
	10537	try testArgs(f80, u128, 1e18);
	10538	try testArgs(f80, u128, 1e22);
	10539	try testArgs(f80, u128, 1e26);
	10540	try testArgs(f80, u128, 1e30);
	10541	try testArgs(f80, u128, 1e34);
	10542	try testArgs(f80, u128, 1e38);
	10543	try testArgs(f80, u128, imax(u128) - 1);
	10544	try testArgs(f80, u128, imax(u128));
	10545
	10546	try testArgs(f80, i256, imin(i256));
	10547	try testArgs(f80, i256, imin(i256) + 1);
	10548	try testArgs(f80, i256, -1e76);
	10549	try testArgs(f80, i256, -1e69);
	10550	try testArgs(f80, i256, -1e62);
	10551	try testArgs(f80, i256, -1e55);
	10552	try testArgs(f80, i256, -1e48);
	10553	try testArgs(f80, i256, -1e41);
	10554	try testArgs(f80, i256, -1e34);
	10555	try testArgs(f80, i256, -1e27);
	10556	try testArgs(f80, i256, -1e20);
	10557	try testArgs(f80, i256, -1e13);
	10558	try testArgs(f80, i256, -1e6);
	10559	try testArgs(f80, i256, -1e0);
	10560	try testArgs(f80, i256, 0);
	10561	try testArgs(f80, i256, 1e0);
	10562	try testArgs(f80, i256, 1e6);
	10563	try testArgs(f80, i256, 1e13);
	10564	try testArgs(f80, i256, 1e20);
	10565	try testArgs(f80, i256, 1e27);
	10566	try testArgs(f80, i256, 1e34);
	10567	try testArgs(f80, i256, 1e41);
	10568	try testArgs(f80, i256, 1e48);
	10569	try testArgs(f80, i256, 1e55);
	10570	try testArgs(f80, i256, 1e62);
	10571	try testArgs(f80, i256, 1e69);
	10572	try testArgs(f80, i256, 1e76);
	10573	try testArgs(f80, i256, imax(i256) - 1);
	10574	try testArgs(f80, i256, imax(i256));
	10575
	10576	try testArgs(f80, u256, 0);
	10577	try testArgs(f80, u256, 1e0);
	10578	try testArgs(f80, u256, 1e7);
	10579	try testArgs(f80, u256, 1e14);
	10580	try testArgs(f80, u256, 1e21);
	10581	try testArgs(f80, u256, 1e28);
	10582	try testArgs(f80, u256, 1e35);
	10583	try testArgs(f80, u256, 1e42);
	10584	try testArgs(f80, u256, 1e49);
	10585	try testArgs(f80, u256, 1e56);
	10586	try testArgs(f80, u256, 1e63);
	10587	try testArgs(f80, u256, 1e70);
	10588	try testArgs(f80, u256, 1e77);
	10589	try testArgs(f80, u256, imax(u256) - 1);
	10590	try testArgs(f80, u256, imax(u256));
	10591
	10592	try testArgs(f128, i8, imin(i8));
	10593	try testArgs(f128, i8, imin(i8) + 1);
	10594	try testArgs(f128, i8, -1e2);
	10595	try testArgs(f128, i8, -1e1);
	10596	try testArgs(f128, i8, -1e0);
	10597	try testArgs(f128, i8, 0);
	10598	try testArgs(f128, i8, 1e0);
	10599	try testArgs(f128, i8, 1e1);
	10600	try testArgs(f128, i8, 1e2);
	10601	try testArgs(f128, i8, imax(i8) - 1);
	10602	try testArgs(f128, i8, imax(i8));
	10603
	10604	try testArgs(f128, u8, 0);
	10605	try testArgs(f128, u8, 1e0);
	10606	try testArgs(f128, u8, 1e1);
	10607	try testArgs(f128, u8, 1e2);
	10608	try testArgs(f128, u8, imax(u8) - 1);
	10609	try testArgs(f128, u8, imax(u8));
	10610
	10611	try testArgs(f128, i16, imin(i16));
	10612	try testArgs(f128, i16, imin(i16) + 1);
	10613	try testArgs(f128, i16, -1e4);
	10614	try testArgs(f128, i16, -1e3);
	10615	try testArgs(f128, i16, -1e2);
	10616	try testArgs(f128, i16, -1e1);
	10617	try testArgs(f128, i16, -1e0);
	10618	try testArgs(f128, i16, 0);
	10619	try testArgs(f128, i16, 1e0);
	10620	try testArgs(f128, i16, 1e1);
	10621	try testArgs(f128, i16, 1e2);
	10622	try testArgs(f128, i16, 1e3);
	10623	try testArgs(f128, i16, 1e4);
	10624	try testArgs(f128, i16, imax(i16) - 1);
	10625	try testArgs(f128, i16, imax(i16));
	10626
	10627	try testArgs(f128, u16, 0);
	10628	try testArgs(f128, u16, 1e0);
	10629	try testArgs(f128, u16, 1e1);
	10630	try testArgs(f128, u16, 1e2);
	10631	try testArgs(f128, u16, 1e3);
	10632	try testArgs(f128, u16, 1e4);
	10633	try testArgs(f128, u16, imax(u16) - 1);
	10634	try testArgs(f128, u16, imax(u16));
	10635
	10636	try testArgs(f128, i32, imin(i32));
	10637	try testArgs(f128, i32, imin(i32) + 1);
	10638	try testArgs(f128, i32, -1e9);
	10639	try testArgs(f128, i32, -1e8);
	10640	try testArgs(f128, i32, -1e7);
	10641	try testArgs(f128, i32, -1e6);
	10642	try testArgs(f128, i32, -1e5);
	10643	try testArgs(f128, i32, -1e4);
	10644	try testArgs(f128, i32, -1e3);
	10645	try testArgs(f128, i32, -1e2);
	10646	try testArgs(f128, i32, -1e1);
	10647	try testArgs(f128, i32, -1e0);
	10648	try testArgs(f128, i32, 0);
	10649	try testArgs(f128, i32, 1e0);
	10650	try testArgs(f128, i32, 1e1);
	10651	try testArgs(f128, i32, 1e2);
	10652	try testArgs(f128, i32, 1e3);
	10653	try testArgs(f128, i32, 1e4);
	10654	try testArgs(f128, i32, 1e5);
	10655	try testArgs(f128, i32, 1e6);
	10656	try testArgs(f128, i32, 1e7);
	10657	try testArgs(f128, i32, 1e8);
	10658	try testArgs(f128, i32, 1e9);
	10659	try testArgs(f128, i32, imax(i32) - 1);
	10660	try testArgs(f128, i32, imax(i32));
	10661
	10662	try testArgs(f128, u32, 0);
	10663	try testArgs(f128, u32, 1e0);
	10664	try testArgs(f128, u32, 1e1);
	10665	try testArgs(f128, u32, 1e2);
	10666	try testArgs(f128, u32, 1e3);
	10667	try testArgs(f128, u32, 1e4);
	10668	try testArgs(f128, u32, 1e5);
	10669	try testArgs(f128, u32, 1e6);
	10670	try testArgs(f128, u32, 1e7);
	10671	try testArgs(f128, u32, 1e8);
	10672	try testArgs(f128, u32, 1e9);
	10673	try testArgs(f128, u32, imax(u32) - 1);
	10674	try testArgs(f128, u32, imax(u32));
	10675
	10676	try testArgs(f128, i64, imin(i64));
	10677	try testArgs(f128, i64, imin(i64) + 1);
	10678	try testArgs(f128, i64, -1e18);
	10679	try testArgs(f128, i64, -1e16);
	10680	try testArgs(f128, i64, -1e14);
	10681	try testArgs(f128, i64, -1e12);
	10682	try testArgs(f128, i64, -1e10);
	10683	try testArgs(f128, i64, -1e8);
	10684	try testArgs(f128, i64, -1e6);
	10685	try testArgs(f128, i64, -1e4);
	10686	try testArgs(f128, i64, -1e2);
	10687	try testArgs(f128, i64, -1e0);
	10688	try testArgs(f128, i64, 0);
	10689	try testArgs(f128, i64, 1e0);
	10690	try testArgs(f128, i64, 1e2);
	10691	try testArgs(f128, i64, 1e4);
	10692	try testArgs(f128, i64, 1e6);
	10693	try testArgs(f128, i64, 1e8);
	10694	try testArgs(f128, i64, 1e10);
	10695	try testArgs(f128, i64, 1e12);
	10696	try testArgs(f128, i64, 1e14);
	10697	try testArgs(f128, i64, 1e16);
	10698	try testArgs(f128, i64, 1e18);
	10699	try testArgs(f128, i64, imax(i64) - 1);
	10700	try testArgs(f128, i64, imax(i64));
	10701
	10702	try testArgs(f128, u64, 0);
	10703	try testArgs(f128, u64, 1e0);
	10704	try testArgs(f128, u64, 1e2);
	10705	try testArgs(f128, u64, 1e4);
	10706	try testArgs(f128, u64, 1e6);
	10707	try testArgs(f128, u64, 1e8);
	10708	try testArgs(f128, u64, 1e10);
	10709	try testArgs(f128, u64, 1e12);
	10710	try testArgs(f128, u64, 1e14);
	10711	try testArgs(f128, u64, 1e16);
	10712	try testArgs(f128, u64, 1e18);
	10713	try testArgs(f128, u64, imax(u64) - 1);
	10714	try testArgs(f128, u64, imax(u64));
	10715
	10716	try testArgs(f128, i128, imin(i128));
	10717	try testArgs(f128, i128, imin(i128) + 1);
	10718	try testArgs(f128, i128, -1e38);
	10719	try testArgs(f128, i128, -1e34);
	10720	try testArgs(f128, i128, -1e30);
	10721	try testArgs(f128, i128, -1e26);
	10722	try testArgs(f128, i128, -1e22);
	10723	try testArgs(f128, i128, -1e18);
	10724	try testArgs(f128, i128, -1e14);
	10725	try testArgs(f128, i128, -1e10);
	10726	try testArgs(f128, i128, -1e6);
	10727	try testArgs(f128, i128, -1e2);
	10728	try testArgs(f128, i128, -1e0);
	10729	try testArgs(f128, i128, 0);
	10730	try testArgs(f128, i128, 1e0);
	10731	try testArgs(f128, i128, 1e2);
	10732	try testArgs(f128, i128, 1e6);
	10733	try testArgs(f128, i128, 1e10);
	10734	try testArgs(f128, i128, 1e14);
	10735	try testArgs(f128, i128, 1e18);
	10736	try testArgs(f128, i128, 1e22);
	10737	try testArgs(f128, i128, 1e26);
	10738	try testArgs(f128, i128, 1e30);
	10739	try testArgs(f128, i128, 1e34);
	10740	try testArgs(f128, i128, 1e38);
	10741	try testArgs(f128, i128, imax(i128) - 1);
	10742	try testArgs(f128, i128, imax(i128));
	10743
	10744	try testArgs(f128, u128, 0);
	10745	try testArgs(f128, u128, 1e0);
	10746	try testArgs(f128, u128, 1e2);
	10747	try testArgs(f128, u128, 1e6);
	10748	try testArgs(f128, u128, 1e10);
	10749	try testArgs(f128, u128, 1e14);
	10750	try testArgs(f128, u128, 1e18);
	10751	try testArgs(f128, u128, 1e22);
	10752	try testArgs(f128, u128, 1e26);
	10753	try testArgs(f128, u128, 1e30);
	10754	try testArgs(f128, u128, 1e34);
	10755	try testArgs(f128, u128, 1e38);
	10756	try testArgs(f128, u128, imax(u128) - 1);
	10757	try testArgs(f128, u128, imax(u128));
	10758
	10759	try testArgs(f128, i256, imin(i256));
	10760	try testArgs(f128, i256, imin(i256) + 1);
	10761	try testArgs(f128, i256, -1e76);
	10762	try testArgs(f128, i256, -1e69);
	10763	try testArgs(f128, i256, -1e62);
	10764	try testArgs(f128, i256, -1e55);
	10765	try testArgs(f128, i256, -1e48);
	10766	try testArgs(f128, i256, -1e41);
	10767	try testArgs(f128, i256, -1e34);
	10768	try testArgs(f128, i256, -1e27);
	10769	try testArgs(f128, i256, -1e20);
	10770	try testArgs(f128, i256, -1e13);
	10771	try testArgs(f128, i256, -1e6);
	10772	try testArgs(f128, i256, -1e0);
	10773	try testArgs(f128, i256, 0);
	10774	try testArgs(f128, i256, 1e0);
	10775	try testArgs(f128, i256, 1e6);
	10776	try testArgs(f128, i256, 1e13);
	10777	try testArgs(f128, i256, 1e20);
	10778	try testArgs(f128, i256, 1e27);
	10779	try testArgs(f128, i256, 1e34);
	10780	try testArgs(f128, i256, 1e41);
	10781	try testArgs(f128, i256, 1e48);
	10782	try testArgs(f128, i256, 1e55);
	10783	try testArgs(f128, i256, 1e62);
	10784	try testArgs(f128, i256, 1e69);
	10785	try testArgs(f128, i256, 1e76);
	10786	try testArgs(f128, i256, imax(i256) - 1);
	10787	try testArgs(f128, i256, imax(i256));
	10788
	10789	try testArgs(f128, u256, 0);
	10790	try testArgs(f128, u256, 1e0);
	10791	try testArgs(f128, u256, 1e7);
	10792	try testArgs(f128, u256, 1e14);
	10793	try testArgs(f128, u256, 1e21);
	10794	try testArgs(f128, u256, 1e28);
	10795	try testArgs(f128, u256, 1e35);
	10796	try testArgs(f128, u256, 1e42);
	10797	try testArgs(f128, u256, 1e49);
	10798	try testArgs(f128, u256, 1e56);
	10799	try testArgs(f128, u256, 1e63);
	10800	try testArgs(f128, u256, 1e70);
	10801	try testArgs(f128, u256, 1e77);
	10802	try testArgs(f128, u256, imax(u256) - 1);
	10803	try testArgs(f128, u256, imax(u256));
	10804	}
8550	10805	};
8551	10806	}
8552	10807
...	...	@@ -11741,6 +13996,22 @@ test floatCast {
11741	13996	try test_float_cast.testFloatVectors();
11742	13997	}
11743	13998
	13999	inline fn intFromFloat(comptime Result: type, comptime Type: type, rhs: Type, comptime _: Type) Result {
	14000	return @intFromFloat(rhs);
	14001	}
	14002	test intFromFloat {
	14003	const test_int_from_float = cast(intFromFloat, .{ .compare = .strict });
	14004	try test_int_from_float.testIntsFromFloats();
	14005	}
	14006
	14007	inline fn floatFromInt(comptime Result: type, comptime Type: type, rhs: Type, comptime _: Type) Result {
	14008	return @floatFromInt(rhs);
	14009	}
	14010	test floatFromInt {
	14011	const test_float_from_int = cast(floatFromInt, .{ .compare = .strict });
	14012	try test_float_from_int.testFloatsFromInts();
	14013	}
	14014
11744	14015	inline fn equal(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs == rhs) {
11745	14016	return lhs == rhs;
11746	14017	}