Commit 1f6f8b0ffe33696ce980955cceacd98171d7ea0c | zig

author	Jacob Young <jacobly@ziglang.org> 2025-05-21 12:15:03-04:00
committer	Jacob Young <jacobly@ziglang.org> 2025-05-28 15:10:22-04:00
log	1f6f8b0ffe33696ce980955cceacd98171d7ea0c
tree	dc720d4fc02e891cb3cd53dc50d174010521eabb
parent	d69f4c48fc6694293573aec6e370d429877a4c7d

x86_64: implement integer `@reduce(.Add)`

16 files changed, 3089 insertions(+), 113 deletions(-)

lib
- std
  - crypto
    Certificate.zig
  - http
    Client.zig
    HeadParser.zig
  - zon
    parse.zig
src
- arch
  - x86_64
    CodeGen.zig
test
- behavior

lib/std/crypto/Certificate.zig+13-19

 @@ -607,7 +607,7 @@ const Date = struct {
             while (month < date.month) : (month += 1) {
                 const days: u64 = std.time.epoch.getDaysInMonth(
                     date.year,
-                    @as(std.time.epoch.Month, @enumFromInt(month)),
+                    @enumFromInt(month),
                 );
                 sec += days * std.time.epoch.secs_per_day;
             }
 @@ -623,15 +623,13 @@ const Date = struct {
 };
 pub fn parseTimeDigits(text: *const [2]u8, min: u8, max: u8) !u8 {
-    const result = if (use_vectors) result: {
+    const nn: @Vector(2, u16) = .{ text[0], text[1] };
-        const nn: @Vector(2, u16) = .{ text[0], text[1] };
+    const zero: @Vector(2, u16) = .{ '0', '0' };
-        const zero: @Vector(2, u16) = .{ '0', '0' };
+    const mm: @Vector(2, u16) = .{ 10, 1 };
-        const mm: @Vector(2, u16) = .{ 10, 1 };
+    const result = @reduce(.Add, (nn -% zero) *% mm);
-        break :result @reduce(.Add, (nn -% zero) *% mm);
-    } else std.fmt.parseInt(u8, text, 10) catch return error.CertificateTimeInvalid;
     if (result < min) return error.CertificateTimeInvalid;
     if (result > max) return error.CertificateTimeInvalid;
-    return @truncate(result);
+    return @intCast(result);
 }
 test parseTimeDigits {
 @@ -647,14 +645,12 @@ test parseTimeDigits {
 }
 pub fn parseYear4(text: *const [4]u8) !u16 {
-    const result = if (use_vectors) result: {
+    const nnnn: @Vector(4, u32) = .{ text[0], text[1], text[2], text[3] };
-        const nnnn: @Vector(4, u32) = .{ text[0], text[1], text[2], text[3] };
+    const zero: @Vector(4, u32) = .{ '0', '0', '0', '0' };
-        const zero: @Vector(4, u32) = .{ '0', '0', '0', '0' };
+    const mmmm: @Vector(4, u32) = .{ 1000, 100, 10, 1 };
-        const mmmm: @Vector(4, u32) = .{ 1000, 100, 10, 1 };
+    const result = @reduce(.Add, (nnnn -% zero) *% mmmm);
-        break :result @reduce(.Add, (nnnn -% zero) *% mmmm);
-    } else std.fmt.parseInt(u16, text, 10) catch return error.CertificateTimeInvalid;
     if (result > 9999) return error.CertificateTimeInvalid;
-    return @truncate(result);
+    return @intCast(result);
 }
 test parseYear4 {
 @@ -858,7 +854,7 @@ pub const der = struct {
         pub fn parse(bytes: []const u8, index: u32) Element.ParseError!Element {
             var i = index;
-            const identifier = @as(Identifier, @bitCast(bytes[i]));
+            const identifier: Identifier = @bitCast(bytes[i]);
             i += 1;
             const size_byte = bytes[i];
             i += 1;
 @@ -872,7 +868,7 @@ pub const der = struct {
                 };
             }
-            const len_size = @as(u7, @truncate(size_byte));
+            const len_size: u7 = @truncate(size_byte);
             if (len_size > @sizeOf(u32)) {
                 return error.CertificateFieldHasInvalidLength;
             }
 @@ -1244,5 +1240,3 @@ pub const rsa = struct {
         return res;
     }
 };
-const use_vectors = @import("builtin").zig_backend != .stage2_x86_64;

lib/std/http/Client.zig+5-8

...	@@ -13,7 +13,6 @@ const net = std.net;	...	@@ -13,7 +13,6 @@ const net = std.net;
13	const Uri = std.Uri;	13	const Uri = std.Uri;
14	const Allocator = mem.Allocator;	14	const Allocator = mem.Allocator;
15	const assert = std.debug.assert;	15	const assert = std.debug.assert;
16	const use_vectors = builtin.zig_backend != .stage2_x86_64;
17		16
18	const Client = @This();	17	const Client = @This();
19	const proto = @import("protocol.zig");	18	const proto = @import("protocol.zig");
...	@@ -594,13 +593,10 @@ pub const Response = struct {	...	@@ -594,13 +593,10 @@ pub const Response = struct {
594	}	593	}
595		594
596	fn parseInt3(text: *const [3]u8) u10 {	595	fn parseInt3(text: *const [3]u8) u10 {
597	if (use_vectors) {	596	const nnn: @Vector(3, u8) = text.*;
598	const nnn: @Vector(3, u8) = text.*;	597	const zero: @Vector(3, u8) = .{ '0', '0', '0' };
599	const zero: @Vector(3, u8) = .{ '0', '0', '0' };	598	const mmm: @Vector(3, u10) = .{ 100, 10, 1 };
600	const mmm: @Vector(3, u10) = .{ 100, 10, 1 };	599	return @reduce(.Add, (nnn -% zero) *% mmm);
601	return @reduce(.Add, @as(@Vector(3, u10), nnn -% zero) *% mmm);
602	}
603	return std.fmt.parseInt(u10, text, 10) catch unreachable;
604	}	600	}
605		601
606	test parseInt3 {	602	test parseInt3 {
...	@@ -1796,5 +1792,6 @@ pub fn fetch(client: *Client, options: FetchOptions) !FetchResult {	...	@@ -1796,5 +1792,6 @@ pub fn fetch(client: *Client, options: FetchOptions) !FetchResult {
1796	}	1792	}
1797		1793
1798	test {	1794	test {
		1795	_ = Response;
1799	_ = &initDefaultProxies;	1796	_ = &initDefaultProxies;
1800	}	1797	}

lib/std/http/HeadParser.zig+14-21

...	@@ -109,27 +109,21 @@ pub fn feed(p: *HeadParser, bytes: []const u8) usize {	...	@@ -109,27 +109,21 @@ pub fn feed(p: *HeadParser, bytes: []const u8) usize {
109	continue;	109	continue;
110	},	110	},
111	else => {	111	else => {
		112	const Vector = @Vector(vector_len, u8);
		113	// const BoolVector = @Vector(vector_len, bool);
		114	const BitVector = @Vector(vector_len, u1);
		115	const SizeVector = @Vector(vector_len, u8);
		116
112	const chunk = bytes[index..][0..vector_len];	117	const chunk = bytes[index..][0..vector_len];
113	const matches = if (use_vectors) matches: {	118	const v: Vector = chunk.*;
114	const Vector = @Vector(vector_len, u8);	119	// depends on https://github.com/ziglang/zig/issues/19755
115	// const BoolVector = @Vector(vector_len, bool);	120	// const matches_r: BitVector = @bitCast(v == @as(Vector, @splat('\r')));
116	const BitVector = @Vector(vector_len, u1);	121	// const matches_n: BitVector = @bitCast(v == @as(Vector, @splat('\n')));
117	const SizeVector = @Vector(vector_len, u8);	122	const matches_r: BitVector = @select(u1, v == @as(Vector, @splat('\r')), @as(Vector, @splat(1)), @as(Vector, @splat(0)));
118		123	const matches_n: BitVector = @select(u1, v == @as(Vector, @splat('\n')), @as(Vector, @splat(1)), @as(Vector, @splat(0)));
119	const v: Vector = chunk.*;	124	const matches_or: SizeVector = matches_r \| matches_n;
120	const matches_r: BitVector = @bitCast(v == @as(Vector, @splat('\r')));	125
121	const matches_n: BitVector = @bitCast(v == @as(Vector, @splat('\n')));	126	const matches = @reduce(.Add, matches_or);
122	const matches_or: SizeVector = matches_r \| matches_n;
123
124	break :matches @reduce(.Add, matches_or);
125	} else matches: {
126	var matches: u8 = 0;
127	for (chunk) \|byte\| switch (byte) {
128	'\r', '\n' => matches += 1,
129	else => {},
130	};
131	break :matches matches;
132	};
133	switch (matches) {	127	switch (matches) {
134	0 => {},	128	0 => {},
135	1 => switch (chunk[vector_len - 1]) {	129	1 => switch (chunk[vector_len - 1]) {
...	@@ -357,7 +351,6 @@ inline fn intShift(comptime T: type, x: anytype) T {	...	@@ -357,7 +351,6 @@ inline fn intShift(comptime T: type, x: anytype) T {
357		351
358	const HeadParser = @This();	352	const HeadParser = @This();
359	const std = @import("std");	353	const std = @import("std");
360	const use_vectors = builtin.zig_backend != .stage2_x86_64;
361	const builtin = @import("builtin");	354	const builtin = @import("builtin");
362		355
363	test feed {	356	test feed {

lib/std/zon/parse.zig-1

...	@@ -3091,7 +3091,6 @@ test "std.zon free on error" {	...	@@ -3091,7 +3091,6 @@ test "std.zon free on error" {
3091		3091
3092	test "std.zon vector" {	3092	test "std.zon vector" {
3093	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/15330	3093	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/15330
3094	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/15329
3095		3094
3096	const gpa = std.testing.allocator;	3095	const gpa = std.testing.allocator;
3097		3096

src/arch/x86_64/CodeGen.zig+3049-45

...	@@ -2389,7 +2389,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -2389,7 +2389,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2389	}	2389	}
2390		2390
2391	fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	2391	fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2392	@setEvalBranchQuota(22_000);	2392	@setEvalBranchQuota(22_500);
2393	const pt = cg.pt;	2393	const pt = cg.pt;
2394	const zcu = pt.zcu;	2394	const zcu = pt.zcu;
2395	const ip = &zcu.intern_pool;	2395	const ip = &zcu.intern_pool;
...	@@ -4328,10 +4328,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -4328,10 +4328,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
4328	else => unreachable,	4328	else => unreachable,
4329	.add, .add_optimized => {},	4329	.add, .add_optimized => {},
4330	.add_wrap => res[0].wrapInt(cg) catch \|err\| switch (err) {	4330	.add_wrap => res[0].wrapInt(cg) catch \|err\| switch (err) {
4331	error.SelectFailed => return cg.fail("failed to select wrap {} {} {}", .{	4331	error.SelectFailed => return cg.fail("failed to select {s} wrap {} {}", .{
		4332	@tagName(air_tag),
4332	cg.typeOf(bin_op.lhs).fmt(pt),	4333	cg.typeOf(bin_op.lhs).fmt(pt),
4333	ops[0].tracking(cg),	4334	res[0].tracking(cg),
4334	ops[1].tracking(cg),
4335	}),	4335	}),
4336	else => \|e\| return e,	4336	else => \|e\| return e,
4337	},	4337	},
...	@@ -14777,10 +14777,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -14777,10 +14777,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
14777	else => unreachable,	14777	else => unreachable,
14778	.sub, .sub_optimized => {},	14778	.sub, .sub_optimized => {},
14779	.sub_wrap => res[0].wrapInt(cg) catch \|err\| switch (err) {	14779	.sub_wrap => res[0].wrapInt(cg) catch \|err\| switch (err) {
14780	error.SelectFailed => return cg.fail("failed to select wrap {} {} {}", .{	14780	error.SelectFailed => return cg.fail("failed to select {s} wrap {} {}", .{
		14781	@tagName(air_tag),
14781	cg.typeOf(bin_op.lhs).fmt(pt),	14782	cg.typeOf(bin_op.lhs).fmt(pt),
14782	ops[0].tracking(cg),	14783	res[0].tracking(cg),
14783	ops[1].tracking(cg),
14784	}),	14784	}),
14785	else => \|e\| return e,	14785	else => \|e\| return e,
14786	},	14786	},
...	@@ -26979,10 +26979,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -26979,10 +26979,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
26979	else => \|e\| return e,	26979	else => \|e\| return e,
26980	};	26980	};
26981	res[0].wrapInt(cg) catch \|err\| switch (err) {	26981	res[0].wrapInt(cg) catch \|err\| switch (err) {
26982	error.SelectFailed => return cg.fail("failed to select wrap {} {} {}", .{	26982	error.SelectFailed => return cg.fail("failed to select {s} wrap {} {}", .{
		26983	@tagName(air_tag),
26983	cg.typeOf(bin_op.lhs).fmt(pt),	26984	cg.typeOf(bin_op.lhs).fmt(pt),
26984	ops[0].tracking(cg),	26985	res[0].tracking(cg),
26985	ops[1].tracking(cg),
26986	}),	26986	}),
26987	else => \|e\| return e,	26987	else => \|e\| return e,
26988	};	26988	};
...	@@ -58664,11 +58664,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -58664,11 +58664,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
58664	switch (air_tag) {	58664	switch (air_tag) {
58665	else => unreachable,	58665	else => unreachable,
58666	.shl => res[0].wrapInt(cg) catch \|err\| switch (err) {	58666	.shl => res[0].wrapInt(cg) catch \|err\| switch (err) {
58667	error.SelectFailed => return cg.fail("failed to select wrap {} {} {} {}", .{	58667	error.SelectFailed => return cg.fail("failed to select {s} wrap {} {}", .{
		58668	@tagName(air_tag),
58668	cg.typeOf(bin_op.lhs).fmt(pt),	58669	cg.typeOf(bin_op.lhs).fmt(pt),
58669	cg.typeOf(bin_op.rhs).fmt(pt),	58670	res[0].tracking(cg),
58670	ops[0].tracking(cg),
58671	ops[1].tracking(cg),
58672	}),	58671	}),
58673	else => \|e\| return e,	58672	else => \|e\| return e,
58674	},	58673	},
...	@@ -58841,10 +58840,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -58841,10 +58840,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
58841	else => \|e\| return e,	58840	else => \|e\| return e,
58842	},	58841	},
58843	}	58842	}
58844	if (ops[1].index != res[0].index) {	58843	if (ops[1].index != res[0].index) try ops[1].die(cg);
58845	try ops[1].die(cg);	58844	ops[1] = res[0];
58846	ops[1] = res[0];
58847	} else cg.temp_type[@intFromEnum(res[0].unwrap(cg).temp)] = .i32;
58848	cg.select(&res, &.{lhs_ty}, &ops, comptime &.{ .{	58845	cg.select(&res, &.{lhs_ty}, &ops, comptime &.{ .{
58849	.required_features = .{ .cmov, null, null, null },	58846	.required_features = .{ .cmov, null, null, null },
58850	.src_constraints = .{ .{ .signed_int = .byte }, .{ .exact_signed_int = 32 }, .any },	58847	.src_constraints = .{ .{ .signed_int = .byte }, .{ .exact_signed_int = 32 }, .any },
...	@@ -116833,14 +116830,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -116833,14 +116830,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
116833	},	116830	},
116834	.reduce => \|air_tag\| if (use_old) try cg.airReduce(inst) else fallback: {	116831	.reduce => \|air_tag\| if (use_old) try cg.airReduce(inst) else fallback: {
116835	const reduce = air_datas[@intFromEnum(inst)].reduce;	116832	const reduce = air_datas[@intFromEnum(inst)].reduce;
116836	const ty = cg.typeOfIndex(inst);	116833	const res_ty = cg.typeOfIndex(inst);
116837	switch (reduce.operation) {	116834	switch (reduce.operation) {
116838	.And, .Or, .Xor => {},	116835	.And, .Or, .Xor => {},
116839	.Min, .Max, .Add, .Mul => break :fallback try cg.airReduce(inst),	116836	.Min, .Max => break :fallback try cg.airReduce(inst),
		116837	.Add => if (cg.floatBits(res_ty)) \|_\| break :fallback try cg.airReduce(inst),
		116838	.Mul => break :fallback try cg.airReduce(inst),
116840	}	116839	}
116841	var ops = try cg.tempsFromOperands(inst, .{reduce.operand});	116840	var ops = try cg.tempsFromOperands(inst, .{reduce.operand});
116842	var res: [1]Temp = undefined;	116841	var res: [1]Temp = undefined;
116843	cg.select(&res, &.{ty}, &ops, switch (reduce.operation) {	116842	cg.select(&res, &.{res_ty}, &ops, switch (reduce.operation) {
116844	.And, .Or, .Xor => switch (@as(Mir.Inst.Tag, switch (reduce.operation) {	116843	.And, .Or, .Xor => switch (@as(Mir.Inst.Tag, switch (reduce.operation) {
116845	else => unreachable,	116844	else => unreachable,
116846	.And => .@"and",	116845	.And => .@"and",
...	@@ -119123,7 +119122,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -119123,7 +119122,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
119123	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },	119122	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
119124	.{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },	119123	.{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
119125	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	119124	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
119126	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10_11_10) },	119125	.{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
119127	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	119126	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
119128	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) },	119127	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) },
119129	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	119128	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
...	@@ -119322,7 +119321,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -119322,7 +119321,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
119322	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },	119321	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
119323	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },	119322	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
119324	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	119323	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
119325	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10_11_10) },	119324	.{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
119326	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	119325	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
119327	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) },	119326	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) },
119328	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	119327	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
...	@@ -120063,7 +120062,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -120063,7 +120062,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
120063	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },	120062	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
120064	.{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },	120063	.{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
120065	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	120064	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
120066	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10_11_10) },	120065	.{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
120067	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	120066	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
120068	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) },	120067	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) },
120069	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	120068	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
...	@@ -120253,7 +120252,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -120253,7 +120252,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
120253	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },	120252	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
120254	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },	120253	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
120255	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	120254	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
120256	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10_11_10) },	120255	.{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
120257	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	120256	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
120258	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) },	120257	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) },
120259	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	120258	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
...	@@ -120800,7 +120799,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -120800,7 +120799,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
120800	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },	120799	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
120801	.{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },	120800	.{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
120802	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	120801	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
120803	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10_11_10) },	120802	.{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
120804	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	120803	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
120805	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) },	120804	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) },
120806	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	120805	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
...	@@ -120981,7 +120980,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -120981,7 +120980,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
120981	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },	120980	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
120982	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },	120981	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
120983	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	120982	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
120984	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10_11_10) },	120983	.{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
120985	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	120984	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
120986	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) },	120985	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) },
120987	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	120986	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
...	@@ -121376,7 +121375,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -121376,7 +121375,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
121376	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },	121375	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
121377	.{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },	121376	.{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
121378	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	121377	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
121379	.{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10_11_10) },	121378	.{ ._, .v_ps, .movhl, .tmp1x, .dst0x, .dst0x, ._ },
121380	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },	121379	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ },
121381	} },	121380	} },
121382	}, .{	121381	}, .{
...	@@ -121549,7 +121548,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -121549,7 +121548,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
121549	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },	121548	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
121550	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },	121549	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
121551	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	121550	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
121552	.{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10_11_10) },	121551	.{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ },
121553	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },	121552	.{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ },
121554	} },	121553	} },
121555	}, .{	121554	}, .{
...	@@ -122278,7 +122277,2998 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -122278,7 +122277,2998 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
122278	} },	122277	} },
122279	} },	122278	} },
122280	},	122279	},
122281	.Min, .Max, .Add, .Mul => unreachable,	122280	.Min, .Max => unreachable,
		122281	.Add => comptime &.{ .{
		122282	.required_features = .{ .sse, null, null, null },
		122283	.dst_constraints = .{ .{ .int = .byte }, .any },
		122284	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		122285	.patterns = &.{
		122286	.{ .src = .{ .mut_mem, .none, .none } },
		122287	.{ .src = .{ .mut_gpr, .none, .none } },
		122288	.{ .src = .{ .to_mut_sse, .none, .none } },
		122289	},
		122290	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122291	.each = .{ .once = &.{} },
		122292	}, .{
		122293	.dst_constraints = .{ .{ .int = .byte }, .any },
		122294	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		122295	.patterns = &.{
		122296	.{ .src = .{ .mut_mem, .none, .none } },
		122297	.{ .src = .{ .to_mut_gpr, .none, .none } },
		122298	},
		122299	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122300	.each = .{ .once = &.{} },
		122301	}, .{
		122302	.required_features = .{ .avx, null, null, null },
		122303	.dst_constraints = .{ .{ .int = .byte }, .any },
		122304	.src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
		122305	.patterns = &.{
		122306	.{ .src = .{ .to_sse, .none, .none } },
		122307	},
		122308	.extra_temps = .{
		122309	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122310	.unused,
		122311	.unused,
		122312	.unused,
		122313	.unused,
		122314	.unused,
		122315	.unused,
		122316	.unused,
		122317	.unused,
		122318	.unused,
		122319	.unused,
		122320	},
		122321	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122322	.each = .{ .once = &.{
		122323	.{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
		122324	.{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
		122325	} },
		122326	}, .{
		122327	.required_features = .{ .sse2, null, null, null },
		122328	.dst_constraints = .{ .{ .int = .byte }, .any },
		122329	.src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any },
		122330	.patterns = &.{
		122331	.{ .src = .{ .to_mut_sse, .none, .none } },
		122332	},
		122333	.extra_temps = .{
		122334	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122335	.unused,
		122336	.unused,
		122337	.unused,
		122338	.unused,
		122339	.unused,
		122340	.unused,
		122341	.unused,
		122342	.unused,
		122343	.unused,
		122344	.unused,
		122345	},
		122346	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122347	.each = .{ .once = &.{
		122348	.{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
		122349	.{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
		122350	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122351	} },
		122352	}, .{
		122353	.required_features = .{ .avx, null, null, null },
		122354	.dst_constraints = .{ .{ .int = .byte }, .any },
		122355	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
		122356	.patterns = &.{
		122357	.{ .src = .{ .to_sse, .none, .none } },
		122358	},
		122359	.extra_temps = .{
		122360	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122361	.unused,
		122362	.unused,
		122363	.unused,
		122364	.unused,
		122365	.unused,
		122366	.unused,
		122367	.unused,
		122368	.unused,
		122369	.unused,
		122370	.unused,
		122371	},
		122372	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122373	.each = .{ .once = &.{
		122374	.{ ._, .vp_d, .srl, .tmp0x, .src0x, .ui(16), ._ },
		122375	.{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
		122376	.{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
		122377	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122378	} },
		122379	}, .{
		122380	.required_features = .{ .sse2, null, null, null },
		122381	.dst_constraints = .{ .{ .int = .byte }, .any },
		122382	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
		122383	.patterns = &.{
		122384	.{ .src = .{ .to_mut_sse, .none, .none } },
		122385	},
		122386	.extra_temps = .{
		122387	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122388	.unused,
		122389	.unused,
		122390	.unused,
		122391	.unused,
		122392	.unused,
		122393	.unused,
		122394	.unused,
		122395	.unused,
		122396	.unused,
		122397	.unused,
		122398	},
		122399	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122400	.each = .{ .once = &.{
		122401	.{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
		122402	.{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ },
		122403	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122404	.{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
		122405	.{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
		122406	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122407	} },
		122408	}, .{
		122409	.required_features = .{ .avx, null, null, null },
		122410	.dst_constraints = .{ .{ .int = .byte }, .any },
		122411	.src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
		122412	.patterns = &.{
		122413	.{ .src = .{ .to_sse, .none, .none } },
		122414	},
		122415	.extra_temps = .{
		122416	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122417	.unused,
		122418	.unused,
		122419	.unused,
		122420	.unused,
		122421	.unused,
		122422	.unused,
		122423	.unused,
		122424	.unused,
		122425	.unused,
		122426	.unused,
		122427	},
		122428	.dst_temps = .{ .{ .rc = .sse }, .unused },
		122429	.each = .{ .once = &.{
		122430	.{ ._, .vp_d, .srl, .tmp0x, .src0x, .ui(16), ._ },
		122431	.{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
		122432	.{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ },
		122433	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122434	} },
		122435	}, .{
		122436	.required_features = .{ .sse2, null, null, null },
		122437	.dst_constraints = .{ .{ .int = .byte }, .any },
		122438	.src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any },
		122439	.patterns = &.{
		122440	.{ .src = .{ .to_mut_sse, .none, .none } },
		122441	},
		122442	.extra_temps = .{
		122443	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122444	.unused,
		122445	.unused,
		122446	.unused,
		122447	.unused,
		122448	.unused,
		122449	.unused,
		122450	.unused,
		122451	.unused,
		122452	.unused,
		122453	.unused,
		122454	},
		122455	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122456	.each = .{ .once = &.{
		122457	.{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
		122458	.{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ },
		122459	.{ ._, .p_b, .add, .tmp0x, .src0x, ._, ._ },
		122460	.{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ },
		122461	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122462	} },
		122463	}, .{
		122464	.required_features = .{ .avx, null, null, null },
		122465	.dst_constraints = .{ .{ .int = .byte }, .any },
		122466	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
		122467	.patterns = &.{
		122468	.{ .src = .{ .to_sse, .none, .none } },
		122469	},
		122470	.extra_temps = .{
		122471	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122472	.unused,
		122473	.unused,
		122474	.unused,
		122475	.unused,
		122476	.unused,
		122477	.unused,
		122478	.unused,
		122479	.unused,
		122480	.unused,
		122481	.unused,
		122482	},
		122483	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122484	.each = .{ .once = &.{
		122485	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		122486	.{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
		122487	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		122488	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122489	.{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
		122490	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122491	} },
		122492	}, .{
		122493	.required_features = .{ .sse2, null, null, null },
		122494	.dst_constraints = .{ .{ .int = .byte }, .any },
		122495	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
		122496	.patterns = &.{
		122497	.{ .src = .{ .to_mut_sse, .none, .none } },
		122498	},
		122499	.extra_temps = .{
		122500	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122501	.unused,
		122502	.unused,
		122503	.unused,
		122504	.unused,
		122505	.unused,
		122506	.unused,
		122507	.unused,
		122508	.unused,
		122509	.unused,
		122510	.unused,
		122511	},
		122512	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122513	.each = .{ .once = &.{
		122514	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		122515	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122516	.{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
		122517	.{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ },
		122518	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122519	.{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
		122520	.{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
		122521	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122522	} },
		122523	}, .{
		122524	.required_features = .{ .avx, null, null, null },
		122525	.dst_constraints = .{ .{ .int = .byte }, .any },
		122526	.src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
		122527	.patterns = &.{
		122528	.{ .src = .{ .to_sse, .none, .none } },
		122529	},
		122530	.extra_temps = .{
		122531	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		122532	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		122533	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122534	.unused,
		122535	.unused,
		122536	.unused,
		122537	.unused,
		122538	.unused,
		122539	.unused,
		122540	.unused,
		122541	.unused,
		122542	},
		122543	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122544	.each = .{ .once = &.{
		122545	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		122546	.{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
		122547	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		122548	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122549	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		122550	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122551	.{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
		122552	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122553	} },
		122554	}, .{
		122555	.required_features = .{ .sse2, null, null, null },
		122556	.dst_constraints = .{ .{ .int = .byte }, .any },
		122557	.src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any },
		122558	.patterns = &.{
		122559	.{ .src = .{ .to_mut_sse, .none, .none } },
		122560	},
		122561	.extra_temps = .{
		122562	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		122563	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		122564	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122565	.unused,
		122566	.unused,
		122567	.unused,
		122568	.unused,
		122569	.unused,
		122570	.unused,
		122571	.unused,
		122572	.unused,
		122573	},
		122574	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122575	.each = .{ .once = &.{
		122576	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		122577	.{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
		122578	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		122579	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		122580	.{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
		122581	.{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ },
		122582	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		122583	.{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
		122584	.{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
		122585	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		122586	} },
		122587	}, .{
		122588	.required_features = .{ .avx, null, null, null },
		122589	.dst_constraints = .{ .{ .int = .byte }, .any },
		122590	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
		122591	.patterns = &.{
		122592	.{ .src = .{ .to_sse, .none, .none } },
		122593	},
		122594	.extra_temps = .{
		122595	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122596	.unused,
		122597	.unused,
		122598	.unused,
		122599	.unused,
		122600	.unused,
		122601	.unused,
		122602	.unused,
		122603	.unused,
		122604	.unused,
		122605	.unused,
		122606	},
		122607	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122608	.each = .{ .once = &.{
		122609	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		122610	.{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
		122611	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		122612	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122613	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		122614	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122615	.{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
		122616	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122617	} },
		122618	}, .{
		122619	.required_features = .{ .sse2, null, null, null },
		122620	.dst_constraints = .{ .{ .int = .byte }, .any },
		122621	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
		122622	.patterns = &.{
		122623	.{ .src = .{ .to_mut_sse, .none, .none } },
		122624	},
		122625	.extra_temps = .{
		122626	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122627	.unused,
		122628	.unused,
		122629	.unused,
		122630	.unused,
		122631	.unused,
		122632	.unused,
		122633	.unused,
		122634	.unused,
		122635	.unused,
		122636	.unused,
		122637	},
		122638	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122639	.each = .{ .once = &.{
		122640	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		122641	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122642	.{ ._, .p_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		122643	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122644	.{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
		122645	.{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ },
		122646	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122647	.{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
		122648	.{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ },
		122649	.{ ._, .p_b, .add, .dst0x, .tmp0x, ._, ._ },
		122650	} },
		122651	}, .{
		122652	.required_features = .{ .avx, null, null, null },
		122653	.dst_constraints = .{ .{ .int = .byte }, .any },
		122654	.src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
		122655	.patterns = &.{
		122656	.{ .src = .{ .to_sse, .none, .none } },
		122657	},
		122658	.extra_temps = .{
		122659	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		122660	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		122661	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122662	.unused,
		122663	.unused,
		122664	.unused,
		122665	.unused,
		122666	.unused,
		122667	.unused,
		122668	.unused,
		122669	.unused,
		122670	},
		122671	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122672	.each = .{ .once = &.{
		122673	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		122674	.{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
		122675	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		122676	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122677	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		122678	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122679	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		122680	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122681	.{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
		122682	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122683	} },
		122684	}, .{
		122685	.required_features = .{ .sse2, null, null, null },
		122686	.dst_constraints = .{ .{ .int = .byte }, .any },
		122687	.src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
		122688	.patterns = &.{
		122689	.{ .src = .{ .to_mut_sse, .none, .none } },
		122690	},
		122691	.extra_temps = .{
		122692	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		122693	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		122694	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122695	.unused,
		122696	.unused,
		122697	.unused,
		122698	.unused,
		122699	.unused,
		122700	.unused,
		122701	.unused,
		122702	.unused,
		122703	},
		122704	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		122705	.each = .{ .once = &.{
		122706	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		122707	.{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
		122708	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		122709	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		122710	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		122711	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		122712	.{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
		122713	.{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ },
		122714	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		122715	.{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
		122716	.{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
		122717	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		122718	} },
		122719	}, .{
		122720	.required_features = .{ .avx2, null, null, null },
		122721	.dst_constraints = .{ .{ .int = .byte }, .any },
		122722	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
		122723	.patterns = &.{
		122724	.{ .src = .{ .to_sse, .none, .none } },
		122725	},
		122726	.extra_temps = .{
		122727	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122728	.unused,
		122729	.unused,
		122730	.unused,
		122731	.unused,
		122732	.unused,
		122733	.unused,
		122734	.unused,
		122735	.unused,
		122736	.unused,
		122737	.unused,
		122738	},
		122739	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122740	.each = .{ .once = &.{
		122741	.{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		122742	.{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
		122743	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		122744	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122745	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		122746	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122747	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		122748	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122749	.{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
		122750	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122751	} },
		122752	}, .{
		122753	.required_features = .{ .avx, null, null, null },
		122754	.dst_constraints = .{ .{ .int = .byte }, .any },
		122755	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
		122756	.patterns = &.{
		122757	.{ .src = .{ .to_sse, .none, .none } },
		122758	},
		122759	.extra_temps = .{
		122760	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122761	.unused,
		122762	.unused,
		122763	.unused,
		122764	.unused,
		122765	.unused,
		122766	.unused,
		122767	.unused,
		122768	.unused,
		122769	.unused,
		122770	.unused,
		122771	},
		122772	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122773	.each = .{ .once = &.{
		122774	.{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		122775	.{ ._, .vp_b, .add, .dst0x, .src0x, .tmp0x, ._ },
		122776	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		122777	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122778	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		122779	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122780	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		122781	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122782	.{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
		122783	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122784	} },
		122785	}, .{
		122786	.required_features = .{ .avx2, null, null, null },
		122787	.dst_constraints = .{ .{ .int = .byte }, .any },
		122788	.src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
		122789	.patterns = &.{
		122790	.{ .src = .{ .to_sse, .none, .none } },
		122791	},
		122792	.extra_temps = .{
		122793	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		122794	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		122795	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122796	.unused,
		122797	.unused,
		122798	.unused,
		122799	.unused,
		122800	.unused,
		122801	.unused,
		122802	.unused,
		122803	.unused,
		122804	},
		122805	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122806	.each = .{ .once = &.{
		122807	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		122808	.{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
		122809	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		122810	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122811	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		122812	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122813	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		122814	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122815	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		122816	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122817	.{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
		122818	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122819	} },
		122820	}, .{
		122821	.required_features = .{ .avx, null, null, null },
		122822	.dst_constraints = .{ .{ .int = .byte }, .any },
		122823	.src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
		122824	.patterns = &.{
		122825	.{ .src = .{ .to_sse, .none, .none } },
		122826	},
		122827	.extra_temps = .{
		122828	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		122829	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		122830	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122831	.unused,
		122832	.unused,
		122833	.unused,
		122834	.unused,
		122835	.unused,
		122836	.unused,
		122837	.unused,
		122838	.unused,
		122839	},
		122840	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122841	.each = .{ .once = &.{
		122842	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		122843	.{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
		122844	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		122845	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122846	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		122847	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122848	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		122849	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122850	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		122851	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122852	.{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
		122853	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122854	} },
		122855	}, .{
		122856	.required_features = .{ .avx512f, null, null, null },
		122857	.dst_constraints = .{ .{ .int = .byte }, .any },
		122858	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
		122859	.patterns = &.{
		122860	.{ .src = .{ .to_mem, .none, .none } },
		122861	},
		122862	.extra_temps = .{
		122863	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122864	.unused,
		122865	.unused,
		122866	.unused,
		122867	.unused,
		122868	.unused,
		122869	.unused,
		122870	.unused,
		122871	.unused,
		122872	.unused,
		122873	.unused,
		122874	},
		122875	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122876	.each = .{ .once = &.{
		122877	.{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
		122878	.{ ._, .vp_b, .add, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
		122879	.{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
		122880	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122881	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		122882	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122883	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		122884	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122885	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		122886	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122887	.{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ },
		122888	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp0x, ._ },
		122889	} },
		122890	}, .{
		122891	.required_features = .{ .avx512f, null, null, null },
		122892	.dst_constraints = .{ .{ .int = .byte }, .any },
		122893	.src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
		122894	.patterns = &.{
		122895	.{ .src = .{ .to_mem, .none, .none } },
		122896	},
		122897	.extra_temps = .{
		122898	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		122899	.{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		122900	.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
		122901	.unused,
		122902	.unused,
		122903	.unused,
		122904	.unused,
		122905	.unused,
		122906	.unused,
		122907	.unused,
		122908	.unused,
		122909	},
		122910	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		122911	.each = .{ .once = &.{
		122912	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		122913	.{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
		122914	.{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
		122915	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
		122916	.{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
		122917	.{ ._, .vp_b, .add, .dst0y, .dst0y, .tmp2y, ._ },
		122918	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		122919	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122920	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		122921	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122922	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		122923	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122924	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		122925	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122926	.{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
		122927	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		122928	} },
		122929	}, .{
		122930	.required_features = .{ .avx2, null, null, null },
		122931	.dst_constraints = .{ .{ .int = .byte }, .any },
		122932	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
		122933	.patterns = &.{
		122934	.{ .src = .{ .to_mem, .none, .none } },
		122935	},
		122936	.extra_temps = .{
		122937	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		122938	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122939	.unused,
		122940	.unused,
		122941	.unused,
		122942	.unused,
		122943	.unused,
		122944	.unused,
		122945	.unused,
		122946	.unused,
		122947	.unused,
		122948	},
		122949	.dst_temps = .{ .{ .rc = .sse }, .unused },
		122950	.each = .{ .once = &.{
		122951	.{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
		122952	.{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
		122953	.{ .@"0:", .vp_b, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		122954	.{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
		122955	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		122956	.{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
		122957	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		122958	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		122959	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		122960	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		122961	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		122962	.{ ._, .vp_d, .srl, .tmp1x, .dst0x, .ui(16), ._ },
		122963	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		122964	.{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
		122965	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		122966	} },
		122967	}, .{
		122968	.required_features = .{ .avx, null, null, null },
		122969	.dst_constraints = .{ .{ .int = .byte }, .any },
		122970	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
		122971	.patterns = &.{
		122972	.{ .src = .{ .to_mem, .none, .none } },
		122973	},
		122974	.extra_temps = .{
		122975	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		122976	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		122977	.unused,
		122978	.unused,
		122979	.unused,
		122980	.unused,
		122981	.unused,
		122982	.unused,
		122983	.unused,
		122984	.unused,
		122985	.unused,
		122986	},
		122987	.dst_temps = .{ .{ .rc = .sse }, .unused },
		122988	.each = .{ .once = &.{
		122989	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
		122990	.{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
		122991	.{ .@"0:", .vp_b, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
		122992	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		122993	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		122994	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		122995	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		122996	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		122997	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		122998	.{ ._, .vp_d, .srl, .tmp1x, .dst0x, .ui(16), ._ },
		122999	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123000	.{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ },
		123001	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123002	} },
		123003	}, .{
		123004	.required_features = .{ .sse2, null, null, null },
		123005	.dst_constraints = .{ .{ .int = .byte }, .any },
		123006	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
		123007	.patterns = &.{
		123008	.{ .src = .{ .to_mem, .none, .none } },
		123009	},
		123010	.extra_temps = .{
		123011	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123012	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		123013	.unused,
		123014	.unused,
		123015	.unused,
		123016	.unused,
		123017	.unused,
		123018	.unused,
		123019	.unused,
		123020	.unused,
		123021	.unused,
		123022	},
		123023	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123024	.each = .{ .once = &.{
		123025	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
		123026	.{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
		123027	.{ .@"0:", .p_b, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
		123028	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		123029	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123030	.{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		123031	.{ ._, .p_b, .add, .dst0x, .tmp1x, ._, ._ },
		123032	.{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		123033	.{ ._, .p_b, .add, .dst0x, .tmp1x, ._, ._ },
		123034	.{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
		123035	.{ ._, .p_d, .srl, .tmp1x, .ui(16), ._, ._ },
		123036	.{ ._, .p_b, .add, .dst0x, .tmp1x, ._, ._ },
		123037	.{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
		123038	.{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ },
		123039	.{ ._, .p_b, .add, .dst0x, .tmp1x, ._, ._ },
		123040	} },
		123041	}, .{
		123042	.required_features = .{ .avx512f, null, null, null },
		123043	.dst_constraints = .{ .{ .int = .byte }, .any },
		123044	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any },
		123045	.patterns = &.{
		123046	.{ .src = .{ .to_mem, .none, .none } },
		123047	},
		123048	.extra_temps = .{
		123049	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123050	.{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123051	.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
		123052	.unused,
		123053	.unused,
		123054	.unused,
		123055	.unused,
		123056	.unused,
		123057	.unused,
		123058	.unused,
		123059	.unused,
		123060	},
		123061	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123062	.each = .{ .once = &.{
		123063	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123064	.{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
		123065	.{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
		123066	.{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
		123067	.{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
		123068	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
		123069	.{ .@"0:", .vp_b, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
		123070	.{ ._, .vp_b, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		123071	.{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
		123072	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123073	.{ ._, .vp_b, .add, .dst0y, .dst0y, .tmp2y, ._ },
		123074	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123075	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123076	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123077	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123078	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123079	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123080	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123081	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123082	.{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
		123083	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123084	} },
		123085	}, .{
		123086	.required_features = .{ .avx2, null, null, null },
		123087	.dst_constraints = .{ .{ .int = .byte }, .any },
		123088	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any },
		123089	.patterns = &.{
		123090	.{ .src = .{ .to_mem, .none, .none } },
		123091	},
		123092	.extra_temps = .{
		123093	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123094	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123095	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		123096	.unused,
		123097	.unused,
		123098	.unused,
		123099	.unused,
		123100	.unused,
		123101	.unused,
		123102	.unused,
		123103	.unused,
		123104	},
		123105	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123106	.each = .{ .once = &.{
		123107	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123108	.{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
		123109	.{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
		123110	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
		123111	.{ .@"0:", .vp_b, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		123112	.{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
		123113	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123114	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123115	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123116	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123117	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123118	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123119	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123120	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123121	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123122	.{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
		123123	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123124	} },
		123125	}, .{
		123126	.required_features = .{ .avx, null, null, null },
		123127	.dst_constraints = .{ .{ .int = .byte }, .any },
		123128	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
		123129	.patterns = &.{
		123130	.{ .src = .{ .to_mem, .none, .none } },
		123131	},
		123132	.extra_temps = .{
		123133	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123134	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123135	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		123136	.unused,
		123137	.unused,
		123138	.unused,
		123139	.unused,
		123140	.unused,
		123141	.unused,
		123142	.unused,
		123143	.unused,
		123144	},
		123145	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123146	.each = .{ .once = &.{
		123147	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123148	.{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
		123149	.{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
		123150	.{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
		123151	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123152	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123153	.{ .@"0:", .vp_b, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
		123154	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		123155	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123156	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123157	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123158	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123159	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123160	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123161	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123162	.{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ },
		123163	.{ ._, .vp_b, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123164	} },
		123165	}, .{
		123166	.required_features = .{ .sse2, null, null, null },
		123167	.dst_constraints = .{ .{ .int = .byte }, .any },
		123168	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any },
		123169	.patterns = &.{
		123170	.{ .src = .{ .to_mem, .none, .none } },
		123171	},
		123172	.extra_temps = .{
		123173	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123174	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123175	.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
		123176	.unused,
		123177	.unused,
		123178	.unused,
		123179	.unused,
		123180	.unused,
		123181	.unused,
		123182	.unused,
		123183	.unused,
		123184	},
		123185	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123186	.each = .{ .once = &.{
		123187	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123188	.{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
		123189	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
		123190	.{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
		123191	.{ .@"0:", .p_b, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
		123192	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		123193	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123194	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123195	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		123196	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123197	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		123198	.{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
		123199	.{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ },
		123200	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		123201	.{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
		123202	.{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ },
		123203	.{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ },
		123204	} },
		123205	}, .{
		123206	.required_features = .{ .slow_incdec, null, null, null },
		123207	.dst_constraints = .{ .{ .int = .byte }, .any },
		123208	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
		123209	.patterns = &.{
		123210	.{ .src = .{ .to_mem, .none, .none } },
		123211	},
		123212	.extra_temps = .{
		123213	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123214	.unused,
		123215	.unused,
		123216	.unused,
		123217	.unused,
		123218	.unused,
		123219	.unused,
		123220	.unused,
		123221	.unused,
		123222	.unused,
		123223	.unused,
		123224	},
		123225	.dst_temps = .{ .{ .rc = .general_purpose }, .unused },
		123226	.clobbers = .{ .eflags = true },
		123227	.each = .{ .once = &.{
		123228	.{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
		123229	.{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
		123230	.{ .@"0:", ._, .add, .dst0b, .memi(.src0b, .tmp0), ._, ._ },
		123231	.{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
		123232	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123233	} },
		123234	}, .{
		123235	.dst_constraints = .{ .{ .int = .byte }, .any },
		123236	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any },
		123237	.patterns = &.{
		123238	.{ .src = .{ .to_mem, .none, .none } },
		123239	},
		123240	.extra_temps = .{
		123241	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123242	.unused,
		123243	.unused,
		123244	.unused,
		123245	.unused,
		123246	.unused,
		123247	.unused,
		123248	.unused,
		123249	.unused,
		123250	.unused,
		123251	.unused,
		123252	},
		123253	.dst_temps = .{ .{ .rc = .general_purpose }, .unused },
		123254	.clobbers = .{ .eflags = true },
		123255	.each = .{ .once = &.{
		123256	.{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ },
		123257	.{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ },
		123258	.{ .@"0:", ._, .add, .dst0b, .memi(.src0b, .tmp0), ._, ._ },
		123259	.{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
		123260	.{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
		123261	} },
		123262	}, .{
		123263	.required_features = .{ .sse, null, null, null },
		123264	.dst_constraints = .{ .{ .int = .word }, .any },
		123265	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		123266	.patterns = &.{
		123267	.{ .src = .{ .mut_mem, .none, .none } },
		123268	.{ .src = .{ .mut_gpr, .none, .none } },
		123269	.{ .src = .{ .to_mut_sse, .none, .none } },
		123270	},
		123271	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		123272	.each = .{ .once = &.{} },
		123273	}, .{
		123274	.dst_constraints = .{ .{ .int = .word }, .any },
		123275	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		123276	.patterns = &.{
		123277	.{ .src = .{ .mut_mem, .none, .none } },
		123278	.{ .src = .{ .to_mut_gpr, .none, .none } },
		123279	},
		123280	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		123281	.each = .{ .once = &.{} },
		123282	}, .{
		123283	.required_features = .{ .avx, null, null, null },
		123284	.dst_constraints = .{ .{ .int = .word }, .any },
		123285	.src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
		123286	.patterns = &.{
		123287	.{ .src = .{ .to_sse, .none, .none } },
		123288	},
		123289	.extra_temps = .{
		123290	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123291	.unused,
		123292	.unused,
		123293	.unused,
		123294	.unused,
		123295	.unused,
		123296	.unused,
		123297	.unused,
		123298	.unused,
		123299	.unused,
		123300	.unused,
		123301	},
		123302	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123303	.each = .{ .once = &.{
		123304	.{ ._, .vp_d, .srl, .tmp0x, .src0x, .ui(16), ._ },
		123305	.{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
		123306	} },
		123307	}, .{
		123308	.required_features = .{ .sse2, null, null, null },
		123309	.dst_constraints = .{ .{ .int = .word }, .any },
		123310	.src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any },
		123311	.patterns = &.{
		123312	.{ .src = .{ .to_mut_sse, .none, .none } },
		123313	},
		123314	.extra_temps = .{
		123315	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123316	.unused,
		123317	.unused,
		123318	.unused,
		123319	.unused,
		123320	.unused,
		123321	.unused,
		123322	.unused,
		123323	.unused,
		123324	.unused,
		123325	.unused,
		123326	},
		123327	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		123328	.each = .{ .once = &.{
		123329	.{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ },
		123330	.{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ },
		123331	.{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
		123332	} },
		123333	}, .{
		123334	.required_features = .{ .avx, null, null, null },
		123335	.dst_constraints = .{ .{ .int = .word }, .any },
		123336	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
		123337	.patterns = &.{
		123338	.{ .src = .{ .to_sse, .none, .none } },
		123339	},
		123340	.extra_temps = .{
		123341	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123342	.unused,
		123343	.unused,
		123344	.unused,
		123345	.unused,
		123346	.unused,
		123347	.unused,
		123348	.unused,
		123349	.unused,
		123350	.unused,
		123351	.unused,
		123352	},
		123353	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123354	.each = .{ .once = &.{
		123355	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		123356	.{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
		123357	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		123358	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123359	} },
		123360	}, .{
		123361	.required_features = .{ .sse2, null, null, null },
		123362	.dst_constraints = .{ .{ .int = .word }, .any },
		123363	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
		123364	.patterns = &.{
		123365	.{ .src = .{ .to_mut_sse, .none, .none } },
		123366	},
		123367	.extra_temps = .{
		123368	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123369	.unused,
		123370	.unused,
		123371	.unused,
		123372	.unused,
		123373	.unused,
		123374	.unused,
		123375	.unused,
		123376	.unused,
		123377	.unused,
		123378	.unused,
		123379	},
		123380	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		123381	.each = .{ .once = &.{
		123382	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		123383	.{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
		123384	.{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
		123385	.{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ },
		123386	.{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
		123387	} },
		123388	}, .{
		123389	.required_features = .{ .avx, null, null, null },
		123390	.dst_constraints = .{ .{ .int = .word }, .any },
		123391	.src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
		123392	.patterns = &.{
		123393	.{ .src = .{ .to_sse, .none, .none } },
		123394	},
		123395	.extra_temps = .{
		123396	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123397	.unused,
		123398	.unused,
		123399	.unused,
		123400	.unused,
		123401	.unused,
		123402	.unused,
		123403	.unused,
		123404	.unused,
		123405	.unused,
		123406	.unused,
		123407	},
		123408	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123409	.each = .{ .once = &.{
		123410	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		123411	.{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
		123412	.{ ._, .vp_d, .srl, .tmp0x, .src0x, .ui(16), ._ },
		123413	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123414	} },
		123415	}, .{
		123416	.required_features = .{ .sse2, null, null, null },
		123417	.dst_constraints = .{ .{ .int = .word }, .any },
		123418	.src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any },
		123419	.patterns = &.{
		123420	.{ .src = .{ .to_mut_sse, .none, .none } },
		123421	},
		123422	.extra_temps = .{
		123423	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123424	.unused,
		123425	.unused,
		123426	.unused,
		123427	.unused,
		123428	.unused,
		123429	.unused,
		123430	.unused,
		123431	.unused,
		123432	.unused,
		123433	.unused,
		123434	},
		123435	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		123436	.each = .{ .once = &.{
		123437	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		123438	.{ ._, .p_w, .add, .tmp0x, .src0x, ._, ._ },
		123439	.{ ._, .p_d, .srl, .dst0x, .ui(16), ._, ._ },
		123440	.{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
		123441	} },
		123442	}, .{
		123443	.required_features = .{ .avx, null, null, null },
		123444	.dst_constraints = .{ .{ .int = .word }, .any },
		123445	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
		123446	.patterns = &.{
		123447	.{ .src = .{ .to_sse, .none, .none } },
		123448	},
		123449	.extra_temps = .{
		123450	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123451	.unused,
		123452	.unused,
		123453	.unused,
		123454	.unused,
		123455	.unused,
		123456	.unused,
		123457	.unused,
		123458	.unused,
		123459	.unused,
		123460	.unused,
		123461	},
		123462	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123463	.each = .{ .once = &.{
		123464	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		123465	.{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
		123466	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		123467	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123468	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		123469	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123470	} },
		123471	}, .{
		123472	.required_features = .{ .sse2, null, null, null },
		123473	.dst_constraints = .{ .{ .int = .word }, .any },
		123474	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
		123475	.patterns = &.{
		123476	.{ .src = .{ .to_mut_sse, .none, .none } },
		123477	},
		123478	.extra_temps = .{
		123479	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123480	.unused,
		123481	.unused,
		123482	.unused,
		123483	.unused,
		123484	.unused,
		123485	.unused,
		123486	.unused,
		123487	.unused,
		123488	.unused,
		123489	.unused,
		123490	},
		123491	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		123492	.each = .{ .once = &.{
		123493	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		123494	.{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
		123495	.{ ._, .p_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		123496	.{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
		123497	.{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ },
		123498	.{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ },
		123499	.{ ._, .p_w, .add, .dst0x, .tmp0x, ._, ._ },
		123500	} },
		123501	}, .{
		123502	.required_features = .{ .avx, null, null, null },
		123503	.dst_constraints = .{ .{ .int = .word }, .any },
		123504	.src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
		123505	.patterns = &.{
		123506	.{ .src = .{ .to_sse, .none, .none } },
		123507	},
		123508	.extra_temps = .{
		123509	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		123510	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123511	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123512	.unused,
		123513	.unused,
		123514	.unused,
		123515	.unused,
		123516	.unused,
		123517	.unused,
		123518	.unused,
		123519	.unused,
		123520	},
		123521	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123522	.each = .{ .once = &.{
		123523	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123524	.{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ },
		123525	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123526	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123527	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123528	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123529	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123530	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123531	} },
		123532	}, .{
		123533	.required_features = .{ .sse2, null, null, null },
		123534	.dst_constraints = .{ .{ .int = .word }, .any },
		123535	.src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
		123536	.patterns = &.{
		123537	.{ .src = .{ .to_mut_sse, .none, .none } },
		123538	},
		123539	.extra_temps = .{
		123540	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		123541	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123542	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123543	.unused,
		123544	.unused,
		123545	.unused,
		123546	.unused,
		123547	.unused,
		123548	.unused,
		123549	.unused,
		123550	.unused,
		123551	},
		123552	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		123553	.each = .{ .once = &.{
		123554	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123555	.{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ },
		123556	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123557	.{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
		123558	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123559	.{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
		123560	.{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
		123561	.{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ },
		123562	.{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
		123563	} },
		123564	}, .{
		123565	.required_features = .{ .avx2, null, null, null },
		123566	.dst_constraints = .{ .{ .int = .word }, .any },
		123567	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
		123568	.patterns = &.{
		123569	.{ .src = .{ .to_sse, .none, .none } },
		123570	},
		123571	.extra_temps = .{
		123572	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123573	.unused,
		123574	.unused,
		123575	.unused,
		123576	.unused,
		123577	.unused,
		123578	.unused,
		123579	.unused,
		123580	.unused,
		123581	.unused,
		123582	.unused,
		123583	},
		123584	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123585	.each = .{ .once = &.{
		123586	.{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		123587	.{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
		123588	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		123589	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123590	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		123591	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123592	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		123593	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123594	} },
		123595	}, .{
		123596	.required_features = .{ .avx, null, null, null },
		123597	.dst_constraints = .{ .{ .int = .word }, .any },
		123598	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
		123599	.patterns = &.{
		123600	.{ .src = .{ .to_sse, .none, .none } },
		123601	},
		123602	.extra_temps = .{
		123603	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123604	.unused,
		123605	.unused,
		123606	.unused,
		123607	.unused,
		123608	.unused,
		123609	.unused,
		123610	.unused,
		123611	.unused,
		123612	.unused,
		123613	.unused,
		123614	},
		123615	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123616	.each = .{ .once = &.{
		123617	.{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		123618	.{ ._, .vp_w, .add, .dst0x, .src0x, .tmp0x, ._ },
		123619	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		123620	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123621	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		123622	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123623	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		123624	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123625	} },
		123626	}, .{
		123627	.required_features = .{ .avx2, null, null, null },
		123628	.dst_constraints = .{ .{ .int = .word }, .any },
		123629	.src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
		123630	.patterns = &.{
		123631	.{ .src = .{ .to_sse, .none, .none } },
		123632	},
		123633	.extra_temps = .{
		123634	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		123635	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123636	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123637	.unused,
		123638	.unused,
		123639	.unused,
		123640	.unused,
		123641	.unused,
		123642	.unused,
		123643	.unused,
		123644	.unused,
		123645	},
		123646	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123647	.each = .{ .once = &.{
		123648	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123649	.{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
		123650	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123651	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123652	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123653	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123654	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123655	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123656	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123657	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123658	} },
		123659	}, .{
		123660	.required_features = .{ .avx, null, null, null },
		123661	.dst_constraints = .{ .{ .int = .word }, .any },
		123662	.src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
		123663	.patterns = &.{
		123664	.{ .src = .{ .to_sse, .none, .none } },
		123665	},
		123666	.extra_temps = .{
		123667	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		123668	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123669	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123670	.unused,
		123671	.unused,
		123672	.unused,
		123673	.unused,
		123674	.unused,
		123675	.unused,
		123676	.unused,
		123677	.unused,
		123678	},
		123679	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123680	.each = .{ .once = &.{
		123681	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123682	.{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
		123683	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123684	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123685	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123686	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123687	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123688	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123689	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123690	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123691	} },
		123692	}, .{
		123693	.required_features = .{ .avx512f, null, null, null },
		123694	.dst_constraints = .{ .{ .int = .word }, .any },
		123695	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
		123696	.patterns = &.{
		123697	.{ .src = .{ .to_mem, .none, .none } },
		123698	},
		123699	.extra_temps = .{
		123700	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123701	.unused,
		123702	.unused,
		123703	.unused,
		123704	.unused,
		123705	.unused,
		123706	.unused,
		123707	.unused,
		123708	.unused,
		123709	.unused,
		123710	.unused,
		123711	},
		123712	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123713	.each = .{ .once = &.{
		123714	.{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
		123715	.{ ._, .vp_w, .add, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
		123716	.{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
		123717	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123718	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		123719	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123720	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		123721	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123722	.{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ },
		123723	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp0x, ._ },
		123724	} },
		123725	}, .{
		123726	.required_features = .{ .avx512f, null, null, null },
		123727	.dst_constraints = .{ .{ .int = .word }, .any },
		123728	.src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
		123729	.patterns = &.{
		123730	.{ .src = .{ .to_mem, .none, .none } },
		123731	},
		123732	.extra_temps = .{
		123733	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		123734	.{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123735	.{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
		123736	.unused,
		123737	.unused,
		123738	.unused,
		123739	.unused,
		123740	.unused,
		123741	.unused,
		123742	.unused,
		123743	.unused,
		123744	},
		123745	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		123746	.each = .{ .once = &.{
		123747	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123748	.{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
		123749	.{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
		123750	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
		123751	.{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
		123752	.{ ._, .vp_w, .add, .dst0y, .dst0y, .tmp2y, ._ },
		123753	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123754	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123755	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123756	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123757	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123758	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123759	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123760	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123761	} },
		123762	}, .{
		123763	.required_features = .{ .avx2, null, null, null },
		123764	.dst_constraints = .{ .{ .int = .word }, .any },
		123765	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
		123766	.patterns = &.{
		123767	.{ .src = .{ .to_mem, .none, .none } },
		123768	},
		123769	.extra_temps = .{
		123770	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123771	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123772	.unused,
		123773	.unused,
		123774	.unused,
		123775	.unused,
		123776	.unused,
		123777	.unused,
		123778	.unused,
		123779	.unused,
		123780	.unused,
		123781	},
		123782	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123783	.each = .{ .once = &.{
		123784	.{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
		123785	.{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
		123786	.{ .@"0:", .vp_w, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		123787	.{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
		123788	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123789	.{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
		123790	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123791	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		123792	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123793	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		123794	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123795	.{ ._, .vp_d, .srl, .tmp1x, .dst0x, .ui(16), ._ },
		123796	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123797	} },
		123798	}, .{
		123799	.required_features = .{ .avx, null, null, null },
		123800	.dst_constraints = .{ .{ .int = .word }, .any },
		123801	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
		123802	.patterns = &.{
		123803	.{ .src = .{ .to_mem, .none, .none } },
		123804	},
		123805	.extra_temps = .{
		123806	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123807	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123808	.unused,
		123809	.unused,
		123810	.unused,
		123811	.unused,
		123812	.unused,
		123813	.unused,
		123814	.unused,
		123815	.unused,
		123816	.unused,
		123817	},
		123818	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123819	.each = .{ .once = &.{
		123820	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
		123821	.{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
		123822	.{ .@"0:", .vp_w, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
		123823	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		123824	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123825	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		123826	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123827	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		123828	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123829	.{ ._, .vp_d, .srl, .tmp1x, .dst0x, .ui(16), ._ },
		123830	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp1x, ._ },
		123831	} },
		123832	}, .{
		123833	.required_features = .{ .sse2, null, null, null },
		123834	.dst_constraints = .{ .{ .int = .word }, .any },
		123835	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
		123836	.patterns = &.{
		123837	.{ .src = .{ .to_mem, .none, .none } },
		123838	},
		123839	.extra_temps = .{
		123840	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123841	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123842	.unused,
		123843	.unused,
		123844	.unused,
		123845	.unused,
		123846	.unused,
		123847	.unused,
		123848	.unused,
		123849	.unused,
		123850	.unused,
		123851	},
		123852	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123853	.each = .{ .once = &.{
		123854	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
		123855	.{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
		123856	.{ .@"0:", .p_w, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
		123857	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		123858	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123859	.{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		123860	.{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
		123861	.{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		123862	.{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
		123863	.{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ },
		123864	.{ ._, .p_d, .srl, .tmp1x, .ui(16), ._, ._ },
		123865	.{ ._, .p_w, .add, .dst0x, .tmp1x, ._, ._ },
		123866	} },
		123867	}, .{
		123868	.required_features = .{ .avx512f, null, null, null },
		123869	.dst_constraints = .{ .{ .int = .word }, .any },
		123870	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any },
		123871	.patterns = &.{
		123872	.{ .src = .{ .to_mem, .none, .none } },
		123873	},
		123874	.extra_temps = .{
		123875	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123876	.{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123877	.{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
		123878	.unused,
		123879	.unused,
		123880	.unused,
		123881	.unused,
		123882	.unused,
		123883	.unused,
		123884	.unused,
		123885	.unused,
		123886	},
		123887	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123888	.each = .{ .once = &.{
		123889	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123890	.{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
		123891	.{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
		123892	.{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
		123893	.{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
		123894	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
		123895	.{ .@"0:", .vp_w, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
		123896	.{ ._, .vp_w, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		123897	.{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
		123898	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123899	.{ ._, .vp_w, .add, .dst0y, .dst0y, .tmp2y, ._ },
		123900	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123901	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123902	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123903	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123904	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123905	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123906	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123907	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123908	} },
		123909	}, .{
		123910	.required_features = .{ .avx2, null, null, null },
		123911	.dst_constraints = .{ .{ .int = .word }, .any },
		123912	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any },
		123913	.patterns = &.{
		123914	.{ .src = .{ .to_mem, .none, .none } },
		123915	},
		123916	.extra_temps = .{
		123917	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123918	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123919	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123920	.unused,
		123921	.unused,
		123922	.unused,
		123923	.unused,
		123924	.unused,
		123925	.unused,
		123926	.unused,
		123927	.unused,
		123928	},
		123929	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123930	.each = .{ .once = &.{
		123931	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123932	.{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
		123933	.{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
		123934	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
		123935	.{ .@"0:", .vp_w, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		123936	.{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
		123937	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123938	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123939	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123940	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123941	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123942	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123943	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123944	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123945	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123946	} },
		123947	}, .{
		123948	.required_features = .{ .avx, null, null, null },
		123949	.dst_constraints = .{ .{ .int = .word }, .any },
		123950	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
		123951	.patterns = &.{
		123952	.{ .src = .{ .to_mem, .none, .none } },
		123953	},
		123954	.extra_temps = .{
		123955	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123956	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123957	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123958	.unused,
		123959	.unused,
		123960	.unused,
		123961	.unused,
		123962	.unused,
		123963	.unused,
		123964	.unused,
		123965	.unused,
		123966	},
		123967	.dst_temps = .{ .{ .rc = .sse }, .unused },
		123968	.each = .{ .once = &.{
		123969	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		123970	.{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
		123971	.{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
		123972	.{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
		123973	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		123974	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123975	.{ .@"0:", .vp_w, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
		123976	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		123977	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		123978	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		123979	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123980	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		123981	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123982	.{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ },
		123983	.{ ._, .vp_w, .add, .dst0x, .dst0x, .tmp2x, ._ },
		123984	} },
		123985	}, .{
		123986	.required_features = .{ .sse2, null, null, null },
		123987	.dst_constraints = .{ .{ .int = .word }, .any },
		123988	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any },
		123989	.patterns = &.{
		123990	.{ .src = .{ .to_mem, .none, .none } },
		123991	},
		123992	.extra_temps = .{
		123993	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		123994	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		123995	.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
		123996	.unused,
		123997	.unused,
		123998	.unused,
		123999	.unused,
		124000	.unused,
		124001	.unused,
		124002	.unused,
		124003	.unused,
		124004	},
		124005	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124006	.each = .{ .once = &.{
		124007	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124008	.{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
		124009	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
		124010	.{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
		124011	.{ .@"0:", .p_w, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
		124012	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		124013	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124014	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124015	.{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
		124016	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		124017	.{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
		124018	.{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ },
		124019	.{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ },
		124020	.{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ },
		124021	} },
		124022	}, .{
		124023	.dst_constraints = .{ .{ .int = .word }, .any },
		124024	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any },
		124025	.patterns = &.{
		124026	.{ .src = .{ .to_mem, .none, .none } },
		124027	},
		124028	.extra_temps = .{
		124029	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124030	.unused,
		124031	.unused,
		124032	.unused,
		124033	.unused,
		124034	.unused,
		124035	.unused,
		124036	.unused,
		124037	.unused,
		124038	.unused,
		124039	.unused,
		124040	},
		124041	.dst_temps = .{ .{ .rc = .general_purpose }, .unused },
		124042	.clobbers = .{ .eflags = true },
		124043	.each = .{ .once = &.{
		124044	.{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ },
		124045	.{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ },
		124046	.{ .@"0:", ._, .add, .dst0w, .memi(.src0w, .tmp0), ._, ._ },
		124047	.{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ },
		124048	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124049	} },
		124050	}, .{
		124051	.required_features = .{ .sse, null, null, null },
		124052	.dst_constraints = .{ .{ .int = .dword }, .any },
		124053	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		124054	.patterns = &.{
		124055	.{ .src = .{ .mut_mem, .none, .none } },
		124056	.{ .src = .{ .mut_gpr, .none, .none } },
		124057	.{ .src = .{ .to_mut_sse, .none, .none } },
		124058	},
		124059	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		124060	.each = .{ .once = &.{} },
		124061	}, .{
		124062	.dst_constraints = .{ .{ .int = .dword }, .any },
		124063	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		124064	.patterns = &.{
		124065	.{ .src = .{ .mut_mem, .none, .none } },
		124066	.{ .src = .{ .to_mut_gpr, .none, .none } },
		124067	},
		124068	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		124069	.each = .{ .once = &.{} },
		124070	}, .{
		124071	.required_features = .{ .avx, null, null, null },
		124072	.dst_constraints = .{ .{ .int = .dword }, .any },
		124073	.src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
		124074	.patterns = &.{
		124075	.{ .src = .{ .to_sse, .none, .none } },
		124076	},
		124077	.extra_temps = .{
		124078	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124079	.unused,
		124080	.unused,
		124081	.unused,
		124082	.unused,
		124083	.unused,
		124084	.unused,
		124085	.unused,
		124086	.unused,
		124087	.unused,
		124088	.unused,
		124089	},
		124090	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124091	.each = .{ .once = &.{
		124092	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		124093	.{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
		124094	} },
		124095	}, .{
		124096	.required_features = .{ .sse2, null, null, null },
		124097	.dst_constraints = .{ .{ .int = .dword }, .any },
		124098	.src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any },
		124099	.patterns = &.{
		124100	.{ .src = .{ .to_mut_sse, .none, .none } },
		124101	},
		124102	.extra_temps = .{
		124103	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124104	.unused,
		124105	.unused,
		124106	.unused,
		124107	.unused,
		124108	.unused,
		124109	.unused,
		124110	.unused,
		124111	.unused,
		124112	.unused,
		124113	.unused,
		124114	},
		124115	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		124116	.each = .{ .once = &.{
		124117	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		124118	.{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
		124119	} },
		124120	}, .{
		124121	.required_features = .{ .avx, null, null, null },
		124122	.dst_constraints = .{ .{ .int = .dword }, .any },
		124123	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
		124124	.patterns = &.{
		124125	.{ .src = .{ .to_sse, .none, .none } },
		124126	},
		124127	.extra_temps = .{
		124128	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124129	.unused,
		124130	.unused,
		124131	.unused,
		124132	.unused,
		124133	.unused,
		124134	.unused,
		124135	.unused,
		124136	.unused,
		124137	.unused,
		124138	.unused,
		124139	},
		124140	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124141	.each = .{ .once = &.{
		124142	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		124143	.{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
		124144	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		124145	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124146	} },
		124147	}, .{
		124148	.required_features = .{ .sse2, null, null, null },
		124149	.dst_constraints = .{ .{ .int = .dword }, .any },
		124150	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
		124151	.patterns = &.{
		124152	.{ .src = .{ .to_mut_sse, .none, .none } },
		124153	},
		124154	.extra_temps = .{
		124155	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124156	.unused,
		124157	.unused,
		124158	.unused,
		124159	.unused,
		124160	.unused,
		124161	.unused,
		124162	.unused,
		124163	.unused,
		124164	.unused,
		124165	.unused,
		124166	},
		124167	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		124168	.each = .{ .once = &.{
		124169	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		124170	.{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
		124171	.{ ._, .p_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		124172	.{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
		124173	} },
		124174	}, .{
		124175	.required_features = .{ .avx, null, null, null },
		124176	.dst_constraints = .{ .{ .int = .dword }, .any },
		124177	.src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
		124178	.patterns = &.{
		124179	.{ .src = .{ .to_sse, .none, .none } },
		124180	},
		124181	.extra_temps = .{
		124182	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124183	.unused,
		124184	.unused,
		124185	.unused,
		124186	.unused,
		124187	.unused,
		124188	.unused,
		124189	.unused,
		124190	.unused,
		124191	.unused,
		124192	.unused,
		124193	},
		124194	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124195	.each = .{ .once = &.{
		124196	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		124197	.{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
		124198	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ },
		124199	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124200	} },
		124201	}, .{
		124202	.required_features = .{ .sse2, null, null, null },
		124203	.dst_constraints = .{ .{ .int = .dword }, .any },
		124204	.src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
		124205	.patterns = &.{
		124206	.{ .src = .{ .to_mut_sse, .none, .none } },
		124207	},
		124208	.extra_temps = .{
		124209	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124210	.unused,
		124211	.unused,
		124212	.unused,
		124213	.unused,
		124214	.unused,
		124215	.unused,
		124216	.unused,
		124217	.unused,
		124218	.unused,
		124219	.unused,
		124220	},
		124221	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		124222	.each = .{ .once = &.{
		124223	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		124224	.{ ._, .p_d, .add, .tmp0x, .src0x, ._, ._ },
		124225	.{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b01_01_01_01), ._ },
		124226	.{ ._, .p_d, .add, .dst0x, .tmp0x, ._, ._ },
		124227	} },
		124228	}, .{
		124229	.required_features = .{ .avx2, null, null, null },
		124230	.dst_constraints = .{ .{ .int = .dword }, .any },
		124231	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
		124232	.patterns = &.{
		124233	.{ .src = .{ .to_sse, .none, .none } },
		124234	},
		124235	.extra_temps = .{
		124236	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124237	.unused,
		124238	.unused,
		124239	.unused,
		124240	.unused,
		124241	.unused,
		124242	.unused,
		124243	.unused,
		124244	.unused,
		124245	.unused,
		124246	.unused,
		124247	},
		124248	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124249	.each = .{ .once = &.{
		124250	.{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		124251	.{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
		124252	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		124253	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124254	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		124255	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124256	} },
		124257	}, .{
		124258	.required_features = .{ .avx, null, null, null },
		124259	.dst_constraints = .{ .{ .int = .dword }, .any },
		124260	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
		124261	.patterns = &.{
		124262	.{ .src = .{ .to_sse, .none, .none } },
		124263	},
		124264	.extra_temps = .{
		124265	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124266	.unused,
		124267	.unused,
		124268	.unused,
		124269	.unused,
		124270	.unused,
		124271	.unused,
		124272	.unused,
		124273	.unused,
		124274	.unused,
		124275	.unused,
		124276	},
		124277	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124278	.each = .{ .once = &.{
		124279	.{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		124280	.{ ._, .vp_d, .add, .dst0x, .src0x, .tmp0x, ._ },
		124281	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		124282	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124283	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		124284	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124285	} },
		124286	}, .{
		124287	.required_features = .{ .avx2, null, null, null },
		124288	.dst_constraints = .{ .{ .int = .dword }, .any },
		124289	.src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
		124290	.patterns = &.{
		124291	.{ .src = .{ .to_sse, .none, .none } },
		124292	},
		124293	.extra_temps = .{
		124294	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		124295	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		124296	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124297	.unused,
		124298	.unused,
		124299	.unused,
		124300	.unused,
		124301	.unused,
		124302	.unused,
		124303	.unused,
		124304	.unused,
		124305	},
		124306	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124307	.each = .{ .once = &.{
		124308	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124309	.{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
		124310	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		124311	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124312	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124313	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124314	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		124315	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124316	} },
		124317	}, .{
		124318	.required_features = .{ .avx, null, null, null },
		124319	.dst_constraints = .{ .{ .int = .dword }, .any },
		124320	.src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
		124321	.patterns = &.{
		124322	.{ .src = .{ .to_sse, .none, .none } },
		124323	},
		124324	.extra_temps = .{
		124325	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		124326	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		124327	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124328	.unused,
		124329	.unused,
		124330	.unused,
		124331	.unused,
		124332	.unused,
		124333	.unused,
		124334	.unused,
		124335	.unused,
		124336	},
		124337	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124338	.each = .{ .once = &.{
		124339	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124340	.{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ },
		124341	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		124342	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124343	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124344	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124345	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		124346	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124347	} },
		124348	}, .{
		124349	.required_features = .{ .avx512f, null, null, null },
		124350	.dst_constraints = .{ .{ .int = .dword }, .any },
		124351	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
		124352	.patterns = &.{
		124353	.{ .src = .{ .to_mem, .none, .none } },
		124354	},
		124355	.extra_temps = .{
		124356	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124357	.unused,
		124358	.unused,
		124359	.unused,
		124360	.unused,
		124361	.unused,
		124362	.unused,
		124363	.unused,
		124364	.unused,
		124365	.unused,
		124366	.unused,
		124367	},
		124368	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124369	.each = .{ .once = &.{
		124370	.{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
		124371	.{ ._, .vp_d, .add, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
		124372	.{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
		124373	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124374	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		124375	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124376	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ },
		124377	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124378	} },
		124379	}, .{
		124380	.required_features = .{ .avx512f, null, null, null },
		124381	.dst_constraints = .{ .{ .int = .dword }, .any },
		124382	.src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
		124383	.patterns = &.{
		124384	.{ .src = .{ .to_mem, .none, .none } },
		124385	},
		124386	.extra_temps = .{
		124387	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		124388	.{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		124389	.{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
		124390	.unused,
		124391	.unused,
		124392	.unused,
		124393	.unused,
		124394	.unused,
		124395	.unused,
		124396	.unused,
		124397	.unused,
		124398	},
		124399	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124400	.each = .{ .once = &.{
		124401	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124402	.{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
		124403	.{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
		124404	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
		124405	.{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
		124406	.{ ._, .vp_d, .add, .dst0y, .dst0y, .tmp2y, ._ },
		124407	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		124408	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124409	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124410	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124411	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		124412	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124413	} },
		124414	}, .{
		124415	.required_features = .{ .avx2, null, null, null },
		124416	.dst_constraints = .{ .{ .int = .dword }, .any },
		124417	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
		124418	.patterns = &.{
		124419	.{ .src = .{ .to_mem, .none, .none } },
		124420	},
		124421	.extra_temps = .{
		124422	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124423	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124424	.unused,
		124425	.unused,
		124426	.unused,
		124427	.unused,
		124428	.unused,
		124429	.unused,
		124430	.unused,
		124431	.unused,
		124432	.unused,
		124433	},
		124434	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124435	.each = .{ .once = &.{
		124436	.{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
		124437	.{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
		124438	.{ .@"0:", .vp_d, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		124439	.{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
		124440	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124441	.{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
		124442	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
		124443	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		124444	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
		124445	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		124446	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
		124447	} },
		124448	}, .{
		124449	.required_features = .{ .avx, null, null, null },
		124450	.dst_constraints = .{ .{ .int = .dword }, .any },
		124451	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
		124452	.patterns = &.{
		124453	.{ .src = .{ .to_mem, .none, .none } },
		124454	},
		124455	.extra_temps = .{
		124456	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124457	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124458	.unused,
		124459	.unused,
		124460	.unused,
		124461	.unused,
		124462	.unused,
		124463	.unused,
		124464	.unused,
		124465	.unused,
		124466	.unused,
		124467	},
		124468	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124469	.each = .{ .once = &.{
		124470	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
		124471	.{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
		124472	.{ .@"0:", .vp_d, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
		124473	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		124474	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124475	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		124476	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
		124477	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		124478	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp1x, ._ },
		124479	} },
		124480	}, .{
		124481	.required_features = .{ .sse2, null, null, null },
		124482	.dst_constraints = .{ .{ .int = .dword }, .any },
		124483	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
		124484	.patterns = &.{
		124485	.{ .src = .{ .to_mem, .none, .none } },
		124486	},
		124487	.extra_temps = .{
		124488	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124489	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124490	.unused,
		124491	.unused,
		124492	.unused,
		124493	.unused,
		124494	.unused,
		124495	.unused,
		124496	.unused,
		124497	.unused,
		124498	.unused,
		124499	},
		124500	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124501	.each = .{ .once = &.{
		124502	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
		124503	.{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
		124504	.{ .@"0:", .p_d, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
		124505	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		124506	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124507	.{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		124508	.{ ._, .p_d, .add, .dst0x, .tmp1x, ._, ._ },
		124509	.{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ },
		124510	.{ ._, .p_d, .add, .dst0x, .tmp1x, ._, ._ },
		124511	} },
		124512	}, .{
		124513	.required_features = .{ .avx512f, null, null, null },
		124514	.dst_constraints = .{ .{ .int = .dword }, .any },
		124515	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any },
		124516	.patterns = &.{
		124517	.{ .src = .{ .to_mem, .none, .none } },
		124518	},
		124519	.extra_temps = .{
		124520	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124521	.{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		124522	.{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
		124523	.unused,
		124524	.unused,
		124525	.unused,
		124526	.unused,
		124527	.unused,
		124528	.unused,
		124529	.unused,
		124530	.unused,
		124531	},
		124532	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124533	.each = .{ .once = &.{
		124534	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124535	.{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
		124536	.{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
		124537	.{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
		124538	.{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
		124539	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
		124540	.{ .@"0:", .vp_d, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
		124541	.{ ._, .vp_d, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		124542	.{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
		124543	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124544	.{ ._, .vp_d, .add, .dst0y, .dst0y, .tmp2y, ._ },
		124545	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		124546	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124547	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124548	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124549	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		124550	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124551	} },
		124552	}, .{
		124553	.required_features = .{ .avx2, null, null, null },
		124554	.dst_constraints = .{ .{ .int = .dword }, .any },
		124555	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any },
		124556	.patterns = &.{
		124557	.{ .src = .{ .to_mem, .none, .none } },
		124558	},
		124559	.extra_temps = .{
		124560	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124561	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		124562	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124563	.unused,
		124564	.unused,
		124565	.unused,
		124566	.unused,
		124567	.unused,
		124568	.unused,
		124569	.unused,
		124570	.unused,
		124571	},
		124572	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124573	.each = .{ .once = &.{
		124574	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124575	.{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
		124576	.{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
		124577	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
		124578	.{ .@"0:", .vp_d, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		124579	.{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
		124580	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124581	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		124582	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124583	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124584	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124585	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		124586	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124587	} },
		124588	}, .{
		124589	.required_features = .{ .avx, null, null, null },
		124590	.dst_constraints = .{ .{ .int = .dword }, .any },
		124591	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
		124592	.patterns = &.{
		124593	.{ .src = .{ .to_mem, .none, .none } },
		124594	},
		124595	.extra_temps = .{
		124596	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124597	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		124598	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124599	.unused,
		124600	.unused,
		124601	.unused,
		124602	.unused,
		124603	.unused,
		124604	.unused,
		124605	.unused,
		124606	.unused,
		124607	},
		124608	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124609	.each = .{ .once = &.{
		124610	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124611	.{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
		124612	.{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
		124613	.{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
		124614	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		124615	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124616	.{ .@"0:", .vp_d, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
		124617	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		124618	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124619	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124620	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124621	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		124622	.{ ._, .vp_d, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124623	} },
		124624	}, .{
		124625	.required_features = .{ .sse2, null, null, null },
		124626	.dst_constraints = .{ .{ .int = .dword }, .any },
		124627	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any },
		124628	.patterns = &.{
		124629	.{ .src = .{ .to_mem, .none, .none } },
		124630	},
		124631	.extra_temps = .{
		124632	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124633	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		124634	.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
		124635	.unused,
		124636	.unused,
		124637	.unused,
		124638	.unused,
		124639	.unused,
		124640	.unused,
		124641	.unused,
		124642	.unused,
		124643	},
		124644	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124645	.each = .{ .once = &.{
		124646	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124647	.{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
		124648	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
		124649	.{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
		124650	.{ .@"0:", .p_d, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
		124651	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		124652	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124653	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124654	.{ ._, .p_d, .add, .dst0x, .tmp2x, ._, ._ },
		124655	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ },
		124656	.{ ._, .p_d, .add, .dst0x, .tmp2x, ._, ._ },
		124657	} },
		124658	}, .{
		124659	.dst_constraints = .{ .{ .int = .dword }, .any },
		124660	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any },
		124661	.patterns = &.{
		124662	.{ .src = .{ .to_mem, .none, .none } },
		124663	},
		124664	.extra_temps = .{
		124665	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124666	.unused,
		124667	.unused,
		124668	.unused,
		124669	.unused,
		124670	.unused,
		124671	.unused,
		124672	.unused,
		124673	.unused,
		124674	.unused,
		124675	.unused,
		124676	},
		124677	.dst_temps = .{ .{ .rc = .general_purpose }, .unused },
		124678	.clobbers = .{ .eflags = true },
		124679	.each = .{ .once = &.{
		124680	.{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ },
		124681	.{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ },
		124682	.{ .@"0:", ._, .add, .dst0d, .memi(.src0d, .tmp0), ._, ._ },
		124683	.{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ },
		124684	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124685	} },
		124686	}, .{
		124687	.required_features = .{ .sse, null, null, null },
		124688	.dst_constraints = .{ .{ .int = .qword }, .any },
		124689	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		124690	.patterns = &.{
		124691	.{ .src = .{ .mut_mem, .none, .none } },
		124692	.{ .src = .{ .mut_gpr, .none, .none } },
		124693	.{ .src = .{ .to_mut_sse, .none, .none } },
		124694	},
		124695	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		124696	.each = .{ .once = &.{} },
		124697	}, .{
		124698	.required_features = .{ .@"64bit", null, null, null },
		124699	.dst_constraints = .{ .{ .int = .qword }, .any },
		124700	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		124701	.patterns = &.{
		124702	.{ .src = .{ .mut_mem, .none, .none } },
		124703	.{ .src = .{ .to_mut_gpr, .none, .none } },
		124704	},
		124705	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		124706	.each = .{ .once = &.{} },
		124707	}, .{
		124708	.required_features = .{ .avx, null, null, null },
		124709	.dst_constraints = .{ .{ .int = .qword }, .any },
		124710	.src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
		124711	.patterns = &.{
		124712	.{ .src = .{ .to_sse, .none, .none } },
		124713	},
		124714	.extra_temps = .{
		124715	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124716	.unused,
		124717	.unused,
		124718	.unused,
		124719	.unused,
		124720	.unused,
		124721	.unused,
		124722	.unused,
		124723	.unused,
		124724	.unused,
		124725	.unused,
		124726	},
		124727	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124728	.each = .{ .once = &.{
		124729	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		124730	.{ ._, .vp_q, .add, .dst0x, .src0x, .tmp0x, ._ },
		124731	} },
		124732	}, .{
		124733	.required_features = .{ .sse2, null, null, null },
		124734	.dst_constraints = .{ .{ .int = .qword }, .any },
		124735	.src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
		124736	.patterns = &.{
		124737	.{ .src = .{ .to_mut_sse, .none, .none } },
		124738	},
		124739	.extra_temps = .{
		124740	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124741	.unused,
		124742	.unused,
		124743	.unused,
		124744	.unused,
		124745	.unused,
		124746	.unused,
		124747	.unused,
		124748	.unused,
		124749	.unused,
		124750	.unused,
		124751	},
		124752	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		124753	.each = .{ .once = &.{
		124754	.{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		124755	.{ ._, .p_q, .add, .dst0x, .tmp0x, ._, ._ },
		124756	} },
		124757	}, .{
		124758	.required_features = .{ .avx2, null, null, null },
		124759	.dst_constraints = .{ .{ .int = .qword }, .any },
		124760	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
		124761	.patterns = &.{
		124762	.{ .src = .{ .to_sse, .none, .none } },
		124763	},
		124764	.extra_temps = .{
		124765	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124766	.unused,
		124767	.unused,
		124768	.unused,
		124769	.unused,
		124770	.unused,
		124771	.unused,
		124772	.unused,
		124773	.unused,
		124774	.unused,
		124775	.unused,
		124776	},
		124777	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124778	.each = .{ .once = &.{
		124779	.{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		124780	.{ ._, .vp_q, .add, .dst0x, .src0x, .tmp0x, ._ },
		124781	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		124782	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124783	} },
		124784	}, .{
		124785	.required_features = .{ .avx, null, null, null },
		124786	.dst_constraints = .{ .{ .int = .qword }, .any },
		124787	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
		124788	.patterns = &.{
		124789	.{ .src = .{ .to_sse, .none, .none } },
		124790	},
		124791	.extra_temps = .{
		124792	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124793	.unused,
		124794	.unused,
		124795	.unused,
		124796	.unused,
		124797	.unused,
		124798	.unused,
		124799	.unused,
		124800	.unused,
		124801	.unused,
		124802	.unused,
		124803	},
		124804	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124805	.each = .{ .once = &.{
		124806	.{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		124807	.{ ._, .vp_q, .add, .dst0x, .src0x, .tmp0x, ._ },
		124808	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		124809	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124810	} },
		124811	}, .{
		124812	.required_features = .{ .avx2, null, null, null },
		124813	.dst_constraints = .{ .{ .int = .qword }, .any },
		124814	.src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
		124815	.patterns = &.{
		124816	.{ .src = .{ .to_sse, .none, .none } },
		124817	},
		124818	.extra_temps = .{
		124819	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124820	.unused,
		124821	.unused,
		124822	.unused,
		124823	.unused,
		124824	.unused,
		124825	.unused,
		124826	.unused,
		124827	.unused,
		124828	.unused,
		124829	.unused,
		124830	},
		124831	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124832	.each = .{ .once = &.{
		124833	.{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		124834	.{ ._, .vp_q, .add, .dst0x, .src0x, .tmp0x, ._ },
		124835	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		124836	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124837	} },
		124838	}, .{
		124839	.required_features = .{ .avx, null, null, null },
		124840	.dst_constraints = .{ .{ .int = .qword }, .any },
		124841	.src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
		124842	.patterns = &.{
		124843	.{ .src = .{ .to_sse, .none, .none } },
		124844	},
		124845	.extra_temps = .{
		124846	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124847	.unused,
		124848	.unused,
		124849	.unused,
		124850	.unused,
		124851	.unused,
		124852	.unused,
		124853	.unused,
		124854	.unused,
		124855	.unused,
		124856	.unused,
		124857	},
		124858	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124859	.each = .{ .once = &.{
		124860	.{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ },
		124861	.{ ._, .vp_q, .add, .dst0x, .src0x, .tmp0x, ._ },
		124862	.{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ },
		124863	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124864	} },
		124865	}, .{
		124866	.required_features = .{ .avx512f, null, null, null },
		124867	.dst_constraints = .{ .{ .int = .qword }, .any },
		124868	.src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
		124869	.patterns = &.{
		124870	.{ .src = .{ .to_mem, .none, .none } },
		124871	},
		124872	.extra_temps = .{
		124873	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124874	.unused,
		124875	.unused,
		124876	.unused,
		124877	.unused,
		124878	.unused,
		124879	.unused,
		124880	.unused,
		124881	.unused,
		124882	.unused,
		124883	.unused,
		124884	},
		124885	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124886	.each = .{ .once = &.{
		124887	.{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
		124888	.{ ._, .vp_q, .add, .dst0y, .dst0y, .memd(.src0y, 32), ._ },
		124889	.{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ },
		124890	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124891	.{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ },
		124892	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp0x, ._ },
		124893	} },
		124894	}, .{
		124895	.required_features = .{ .avx512f, null, null, null },
		124896	.dst_constraints = .{ .{ .int = .qword }, .any },
		124897	.src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
		124898	.patterns = &.{
		124899	.{ .src = .{ .to_mem, .none, .none } },
		124900	},
		124901	.extra_temps = .{
		124902	.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
		124903	.{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		124904	.{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
		124905	.unused,
		124906	.unused,
		124907	.unused,
		124908	.unused,
		124909	.unused,
		124910	.unused,
		124911	.unused,
		124912	.unused,
		124913	},
		124914	.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
		124915	.each = .{ .once = &.{
		124916	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		124917	.{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ },
		124918	.{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ },
		124919	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .lea(.tmp0y), ._ },
		124920	.{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ },
		124921	.{ ._, .vp_q, .add, .dst0y, .dst0y, .tmp2y, ._ },
		124922	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		124923	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124924	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		124925	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
		124926	} },
		124927	}, .{
		124928	.required_features = .{ .avx2, null, null, null },
		124929	.dst_constraints = .{ .{ .int = .qword }, .any },
		124930	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
		124931	.patterns = &.{
		124932	.{ .src = .{ .to_mem, .none, .none } },
		124933	},
		124934	.extra_temps = .{
		124935	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124936	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124937	.unused,
		124938	.unused,
		124939	.unused,
		124940	.unused,
		124941	.unused,
		124942	.unused,
		124943	.unused,
		124944	.unused,
		124945	.unused,
		124946	},
		124947	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124948	.each = .{ .once = &.{
		124949	.{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ },
		124950	.{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ },
		124951	.{ .@"0:", .vp_q, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		124952	.{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
		124953	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124954	.{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ },
		124955	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp1x, ._ },
		124956	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		124957	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp1x, ._ },
		124958	} },
		124959	}, .{
		124960	.required_features = .{ .avx, null, null, null },
		124961	.dst_constraints = .{ .{ .int = .qword }, .any },
		124962	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
		124963	.patterns = &.{
		124964	.{ .src = .{ .to_mem, .none, .none } },
		124965	},
		124966	.extra_temps = .{
		124967	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124968	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124969	.unused,
		124970	.unused,
		124971	.unused,
		124972	.unused,
		124973	.unused,
		124974	.unused,
		124975	.unused,
		124976	.unused,
		124977	.unused,
		124978	},
		124979	.dst_temps = .{ .{ .rc = .sse }, .unused },
		124980	.each = .{ .once = &.{
		124981	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
		124982	.{ ._, .v_dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
		124983	.{ .@"0:", .vp_q, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
		124984	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		124985	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		124986	.{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		124987	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp1x, ._ },
		124988	} },
		124989	}, .{
		124990	.required_features = .{ .sse2, null, null, null },
		124991	.dst_constraints = .{ .{ .int = .qword }, .any },
		124992	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
		124993	.patterns = &.{
		124994	.{ .src = .{ .to_mem, .none, .none } },
		124995	},
		124996	.extra_temps = .{
		124997	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		124998	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		124999	.unused,
		125000	.unused,
		125001	.unused,
		125002	.unused,
		125003	.unused,
		125004	.unused,
		125005	.unused,
		125006	.unused,
		125007	.unused,
		125008	},
		125009	.dst_temps = .{ .{ .rc = .sse }, .unused },
		125010	.each = .{ .once = &.{
		125011	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ },
		125012	.{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ },
		125013	.{ .@"0:", .p_q, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
		125014	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		125015	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		125016	.{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ },
		125017	.{ ._, .p_q, .add, .dst0x, .tmp1x, ._, ._ },
		125018	} },
		125019	}, .{
		125020	.required_features = .{ .avx512f, null, null, null },
		125021	.dst_constraints = .{ .{ .int = .qword }, .any },
		125022	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any },
		125023	.patterns = &.{
		125024	.{ .src = .{ .to_mem, .none, .none } },
		125025	},
		125026	.extra_temps = .{
		125027	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		125028	.{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		125029	.{ .type = .vector_4_u64, .kind = .{ .rc = .sse } },
		125030	.unused,
		125031	.unused,
		125032	.unused,
		125033	.unused,
		125034	.unused,
		125035	.unused,
		125036	.unused,
		125037	.unused,
		125038	},
		125039	.dst_temps = .{ .{ .rc = .sse }, .unused },
		125040	.each = .{ .once = &.{
		125041	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		125042	.{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
		125043	.{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ },
		125044	.{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ },
		125045	.{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ },
		125046	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ },
		125047	.{ .@"0:", .vp_q, .add, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ },
		125048	.{ ._, .vp_q, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		125049	.{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ },
		125050	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		125051	.{ ._, .vp_q, .add, .dst0y, .dst0y, .tmp2y, ._ },
		125052	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		125053	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
		125054	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		125055	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
		125056	} },
		125057	}, .{
		125058	.required_features = .{ .avx2, null, null, null },
		125059	.dst_constraints = .{ .{ .int = .qword }, .any },
		125060	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any },
		125061	.patterns = &.{
		125062	.{ .src = .{ .to_mem, .none, .none } },
		125063	},
		125064	.extra_temps = .{
		125065	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		125066	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		125067	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		125068	.unused,
		125069	.unused,
		125070	.unused,
		125071	.unused,
		125072	.unused,
		125073	.unused,
		125074	.unused,
		125075	.unused,
		125076	},
		125077	.dst_temps = .{ .{ .rc = .sse }, .unused },
		125078	.each = .{ .once = &.{
		125079	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		125080	.{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ },
		125081	.{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ },
		125082	.{ ._, .vp_, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
		125083	.{ .@"0:", .vp_q, .add, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ },
		125084	.{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ },
		125085	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		125086	.{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		125087	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
		125088	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		125089	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
		125090	} },
		125091	}, .{
		125092	.required_features = .{ .avx, null, null, null },
		125093	.dst_constraints = .{ .{ .int = .qword }, .any },
		125094	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
		125095	.patterns = &.{
		125096	.{ .src = .{ .to_mem, .none, .none } },
		125097	},
		125098	.extra_temps = .{
		125099	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		125100	.{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		125101	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		125102	.unused,
		125103	.unused,
		125104	.unused,
		125105	.unused,
		125106	.unused,
		125107	.unused,
		125108	.unused,
		125109	.unused,
		125110	},
		125111	.dst_temps = .{ .{ .rc = .sse }, .unused },
		125112	.each = .{ .once = &.{
		125113	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		125114	.{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ },
		125115	.{ ._, ._, .mov, .tmp0d, .sia(-48, .src0, .add_size), ._, ._ },
		125116	.{ ._, .v_ps, .@"and", .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ },
		125117	.{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ },
		125118	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
		125119	.{ .@"0:", .vp_q, .add, .dst0x, .dst0x, .memi(.src0x, .tmp0), ._ },
		125120	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		125121	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		125122	.{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		125123	.{ ._, .vp_q, .add, .dst0x, .dst0x, .tmp2x, ._ },
		125124	} },
		125125	}, .{
		125126	.required_features = .{ .sse2, null, null, null },
		125127	.dst_constraints = .{ .{ .int = .qword }, .any },
		125128	.src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any },
		125129	.patterns = &.{
		125130	.{ .src = .{ .to_mem, .none, .none } },
		125131	},
		125132	.extra_temps = .{
		125133	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		125134	.{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ .ref = .src0 } } },
		125135	.{ .type = .vector_2_u64, .kind = .{ .rc = .sse } },
		125136	.unused,
		125137	.unused,
		125138	.unused,
		125139	.unused,
		125140	.unused,
		125141	.unused,
		125142	.unused,
		125143	.unused,
		125144	},
		125145	.dst_temps = .{ .{ .rc = .sse }, .unused },
		125146	.each = .{ .once = &.{
		125147	.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
		125148	.{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ },
		125149	.{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ },
		125150	.{ ._, .p_, .@"and", .dst0x, .memad(.src0x, .add_size, -16), ._, ._ },
		125151	.{ .@"0:", .p_q, .add, .dst0x, .memi(.src0x, .tmp0), ._, ._ },
		125152	.{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ },
		125153	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		125154	.{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ },
		125155	.{ ._, .p_q, .add, .dst0x, .tmp2x, ._, ._ },
		125156	} },
		125157	}, .{
		125158	.required_features = .{ .@"64bit", null, null, null },
		125159	.dst_constraints = .{ .{ .int = .qword }, .any },
		125160	.src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any },
		125161	.patterns = &.{
		125162	.{ .src = .{ .to_mem, .none, .none } },
		125163	},
		125164	.extra_temps = .{
		125165	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		125166	.unused,
		125167	.unused,
		125168	.unused,
		125169	.unused,
		125170	.unused,
		125171	.unused,
		125172	.unused,
		125173	.unused,
		125174	.unused,
		125175	.unused,
		125176	},
		125177	.dst_temps = .{ .{ .rc = .general_purpose }, .unused },
		125178	.clobbers = .{ .eflags = true },
		125179	.each = .{ .once = &.{
		125180	.{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ },
		125181	.{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ },
		125182	.{ .@"0:", ._, .add, .dst0q, .memi(.src0q, .tmp0), ._, ._ },
		125183	.{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
		125184	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		125185	} },
		125186	}, .{
		125187	.required_features = .{ .sse, null, null, null },
		125188	.dst_constraints = .{ .{ .int = .xword }, .any },
		125189	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		125190	.patterns = &.{
		125191	.{ .src = .{ .mut_mem, .none, .none } },
		125192	.{ .src = .{ .mut_gpr, .none, .none } },
		125193	.{ .src = .{ .to_mut_sse, .none, .none } },
		125194	},
		125195	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		125196	.each = .{ .once = &.{} },
		125197	}, .{
		125198	.dst_constraints = .{ .{ .int = .xword }, .any },
		125199	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		125200	.patterns = &.{
		125201	.{ .src = .{ .to_mut_mem, .none, .none } },
		125202	},
		125203	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		125204	.each = .{ .once = &.{} },
		125205	}, .{
		125206	.required_features = .{ .avx, null, null, null },
		125207	.dst_constraints = .{ .{ .int = .yword }, .any },
		125208	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		125209	.patterns = &.{
		125210	.{ .src = .{ .mut_mem, .none, .none } },
		125211	.{ .src = .{ .mut_gpr, .none, .none } },
		125212	.{ .src = .{ .to_mut_sse, .none, .none } },
		125213	},
		125214	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		125215	.each = .{ .once = &.{} },
		125216	}, .{
		125217	.dst_constraints = .{ .{ .int = .yword }, .any },
		125218	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		125219	.patterns = &.{
		125220	.{ .src = .{ .to_mut_mem, .none, .none } },
		125221	},
		125222	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		125223	.each = .{ .once = &.{} },
		125224	}, .{
		125225	.dst_constraints = .{ .any_int, .any },
		125226	.src_constraints = .{ .{ .vec_len = 1 }, .any, .any },
		125227	.patterns = &.{
		125228	.{ .src = .{ .to_mut_mem, .none, .none } },
		125229	},
		125230	.dst_temps = .{ .{ .ref = .src0 }, .unused },
		125231	.each = .{ .once = &.{} },
		125232	}, .{
		125233	.required_features = .{ .@"64bit", null, null, null },
		125234	.dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any },
		125235	.src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any },
		125236	.patterns = &.{
		125237	.{ .src = .{ .to_mem, .none, .none } },
		125238	},
		125239	.extra_temps = .{
		125240	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
		125241	.{ .type = .u32, .kind = .{ .reg = .rsi } },
		125242	.{ .type = .usize, .kind = .{ .reg = .rdi } },
		125243	.{ .type = .u64, .kind = .{ .reg = .rcx } },
		125244	.unused,
		125245	.unused,
		125246	.unused,
		125247	.unused,
		125248	.unused,
		125249	.unused,
		125250	.unused,
		125251	},
		125252	.dst_temps = .{ .mem, .unused },
		125253	.clobbers = .{ .eflags = true },
		125254	.each = .{ .once = &.{
		125255	.{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ },
		125256	.{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ },
		125257	.{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ },
		125258	.{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_size_div_8), ._, ._ },
		125259	.{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ },
		125260	.{ .@"0:", ._, .mov, .tmp1p, .sa(.dst0, .sub_size_div_8), ._, ._ },
		125261	.{ ._, ._, .lea, .tmp2q, .memi(.src0, .tmp0), ._, ._ },
		125262	.{ ._, ._c, .cl, ._, ._, ._, ._ },
		125263	.{ .@"1:", ._, .mov, .tmp3q, .leasia(.tmp2q, .@"8", .tmp1, .add_src0_elem_size), ._, ._ },
		125264	.{ ._, ._, .adc, .memsia(.dst0q, .@"8", .tmp1, .add_size), .tmp3q, ._, ._ },
		125265	.{ ._, ._c, .in, .tmp1p, ._, ._, ._ },
		125266	.{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
		125267	.{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ },
		125268	.{ ._, ._nb, .j, .@"0b", ._, ._, ._ },
		125269	} },
		125270	} },
		125271	.Mul => unreachable,
122282	}) catch \|err\| switch (err) {	125272	}) catch \|err\| switch (err) {
122283	error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{	125273	error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{
122284	@tagName(air_tag),	125274	@tagName(air_tag),
...	@@ -122287,6 +125277,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {	...	@@ -122287,6 +125277,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
122287	}),	125277	}),
122288	else => \|e\| return e,	125278	else => \|e\| return e,
122289	};	125279	};
		125280	switch (reduce.operation) {
		125281	.And, .Or, .Xor, .Min, .Max => {},
		125282	.Add, .Mul => if (cg.intInfo(res_ty)) \|_\| res[0].wrapInt(cg) catch \|err\| switch (err) {
		125283	error.SelectFailed => return cg.fail("failed to select {s} wrap {} {}", .{
		125284	@tagName(air_tag),
		125285	res_ty.fmt(pt),
		125286	res[0].tracking(cg),
		125287	}),
		125288	else => \|e\| return e,
		125289	},
		125290	}
122290	try res[0].finish(inst, &.{reduce.operand}, &ops, cg);	125291	try res[0].finish(inst, &.{reduce.operand}, &ops, cg);
122291	},	125292	},
122292	.splat => \|air_tag\| if (use_old) try cg.airSplat(inst) else fallback: {	125293	.splat => \|air_tag\| if (use_old) try cg.airSplat(inst) else fallback: {
...	@@ -142314,10 +145315,10 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {	...	@@ -142314,10 +145315,10 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
142314	) else try self.asmRegisterRegister(	145315	) else try self.asmRegisterRegister(
142315	.{ mir_tag[0], .andn },	145316	.{ mir_tag[0], .andn },
142316	mask_alias,	145317	mask_alias,
142317	if (other_mcv.isRegister())	145318	registerAlias(if (other_mcv.isRegister())
142318	other_mcv.getReg().?	145319	other_mcv.getReg().?
142319	else	145320	else
142320	try self.copyToTmpRegister(ty, other_mcv),	145321	try self.copyToTmpRegister(ty, other_mcv), abi_size),
142321	);	145322	);
142322	try self.asmRegisterRegister(.{ mir_tag[0], .@"or" }, dst_alias, mask_alias);	145323	try self.asmRegisterRegister(.{ mir_tag[0], .@"or" }, dst_alias, mask_alias);
142323	}	145324	}
...	@@ -146202,7 +149203,7 @@ const Temp = struct {	...	@@ -146202,7 +149203,7 @@ const Temp = struct {
146202	}, .{	149203	}, .{
146203	.src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any, .any },	149204	.src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = 128 } }, .any, .any },
146204	.patterns = &.{	149205	.patterns = &.{
146205	.{ .src = .{ .mut_mem, .none, .none } },	149206	.{ .src = .{ .to_mut_mem, .none, .none } },
146206	},	149207	},
146207	.dst_temps = .{ .{ .ref = .src0 }, .unused },	149208	.dst_temps = .{ .{ .ref = .src0 }, .unused },
146208	.each = .{ .once = &.{} },	149209	.each = .{ .once = &.{} },
...	@@ -146210,7 +149211,7 @@ const Temp = struct {	...	@@ -146210,7 +149211,7 @@ const Temp = struct {
146210	.required_features = .{ .@"64bit", null, null, null },	149211	.required_features = .{ .@"64bit", null, null, null },
146211	.src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } }, .any, .any },	149212	.src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = 64 } }, .any, .any },
146212	.patterns = &.{	149213	.patterns = &.{
146213	.{ .src = .{ .mut_mem, .none, .none } },	149214	.{ .src = .{ .to_mut_mem, .none, .none } },
146214	},	149215	},
146215	.extra_temps = .{	149216	.extra_temps = .{
146216	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },	149217	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
...	@@ -146236,7 +149237,7 @@ const Temp = struct {	...	@@ -146236,7 +149237,7 @@ const Temp = struct {
146236	.required_features = .{ .@"64bit", null, null, null },	149237	.required_features = .{ .@"64bit", null, null, null },
146237	.src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } }, .any, .any },	149238	.src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = 64 } }, .any, .any },
146238	.patterns = &.{	149239	.patterns = &.{
146239	.{ .src = .{ .mut_mem, .none, .none } },	149240	.{ .src = .{ .to_mut_mem, .none, .none } },
146240	},	149241	},
146241	.dst_temps = .{ .{ .ref = .src0 }, .unused },	149242	.dst_temps = .{ .{ .ref = .src0 }, .unused },
146242	.each = .{ .once = &.{	149243	.each = .{ .once = &.{
...	@@ -146246,7 +149247,7 @@ const Temp = struct {	...	@@ -146246,7 +149247,7 @@ const Temp = struct {
146246	.required_features = .{ .@"64bit", null, null, null },	149247	.required_features = .{ .@"64bit", null, null, null },
146247	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },	149248	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
146248	.patterns = &.{	149249	.patterns = &.{
146249	.{ .src = .{ .mut_mem, .none, .none } },	149250	.{ .src = .{ .to_mut_mem, .none, .none } },
146250	},	149251	},
146251	.extra_temps = .{	149252	.extra_temps = .{
146252	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },	149253	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
...	@@ -146275,7 +149276,7 @@ const Temp = struct {	...	@@ -146275,7 +149276,7 @@ const Temp = struct {
146275	.required_features = .{ .@"64bit", null, null, null },	149276	.required_features = .{ .@"64bit", null, null, null },
146276	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },	149277	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
146277	.patterns = &.{	149278	.patterns = &.{
146278	.{ .src = .{ .mut_mem, .none, .none } },	149279	.{ .src = .{ .to_mut_mem, .none, .none } },
146279	},	149280	},
146280	.extra_temps = .{	149281	.extra_temps = .{
146281	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },	149282	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
...	@@ -146301,7 +149302,7 @@ const Temp = struct {	...	@@ -146301,7 +149302,7 @@ const Temp = struct {
146301	.required_features = .{ .@"64bit", null, null, null },	149302	.required_features = .{ .@"64bit", null, null, null },
146302	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },	149303	.src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
146303	.patterns = &.{	149304	.patterns = &.{
146304	.{ .src = .{ .mut_mem, .none, .none } },	149305	.{ .src = .{ .to_mut_mem, .none, .none } },
146305	},	149306	},
146306	.extra_temps = .{	149307	.extra_temps = .{
146307	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },	149308	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
...	@@ -146328,7 +149329,7 @@ const Temp = struct {	...	@@ -146328,7 +149329,7 @@ const Temp = struct {
146328	.required_features = .{ .@"64bit", null, null, null },	149329	.required_features = .{ .@"64bit", null, null, null },
146329	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },	149330	.src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
146330	.patterns = &.{	149331	.patterns = &.{
146331	.{ .src = .{ .mut_mem, .none, .none } },	149332	.{ .src = .{ .to_mut_mem, .none, .none } },
146332	},	149333	},
146333	.extra_temps = .{	149334	.extra_temps = .{
146334	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },	149335	.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
...	@@ -148340,7 +151341,7 @@ const Temp = struct {	...	@@ -148340,7 +151341,7 @@ const Temp = struct {
148340	.required_features = .{ .@"64bit", null, null, null },	151341	.required_features = .{ .@"64bit", null, null, null },
148341	.src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },	151342	.src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any },
148342	.patterns = &.{	151343	.patterns = &.{
148343	.{ .src = .{ .mut_mem, .none, .none } },	151344	.{ .src = .{ .to_mut_mem, .none, .none } },
148344	},	151345	},
148345	.extra_temps = .{	151346	.extra_temps = .{
148346	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },	151347	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
...	@@ -148372,7 +151373,7 @@ const Temp = struct {	...	@@ -148372,7 +151373,7 @@ const Temp = struct {
148372	.required_features = .{ .@"64bit", null, null, null },	151373	.required_features = .{ .@"64bit", null, null, null },
148373	.src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },	151374	.src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any },
148374	.patterns = &.{	151375	.patterns = &.{
148375	.{ .src = .{ .mut_mem, .none, .none } },	151376	.{ .src = .{ .to_mut_mem, .none, .none } },
148376	},	151377	},
148377	.extra_temps = .{	151378	.extra_temps = .{
148378	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },	151379	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
...	@@ -148401,7 +151402,7 @@ const Temp = struct {	...	@@ -148401,7 +151402,7 @@ const Temp = struct {
148401	.required_features = .{ .@"64bit", null, null, null },	151402	.required_features = .{ .@"64bit", null, null, null },
148402	.src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },	151403	.src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any },
148403	.patterns = &.{	151404	.patterns = &.{
148404	.{ .src = .{ .mut_mem, .none, .none } },	151405	.{ .src = .{ .to_mut_mem, .none, .none } },
148405	},	151406	},
148406	.extra_temps = .{	151407	.extra_temps = .{
148407	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },	151408	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
...	@@ -148431,7 +151432,7 @@ const Temp = struct {	...	@@ -148431,7 +151432,7 @@ const Temp = struct {
148431	.required_features = .{ .@"64bit", null, null, null },	151432	.required_features = .{ .@"64bit", null, null, null },
148432	.src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },	151433	.src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any },
148433	.patterns = &.{	151434	.patterns = &.{
148434	.{ .src = .{ .mut_mem, .none, .none } },	151435	.{ .src = .{ .to_mut_mem, .none, .none } },
148435	},	151436	},
148436	.extra_temps = .{	151437	.extra_temps = .{
148437	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },	151438	.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
...	@@ -151815,12 +154816,12 @@ const Select = struct {	...	@@ -151815,12 +154816,12 @@ const Select = struct {
151815	const sub_src0_elem_size: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"1" };	154816	const sub_src0_elem_size: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"1" };
151816	const add_src0_elem_size_mul_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" };	154817	const add_src0_elem_size_mul_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" };
151817	const sub_src0_elem_size_mul_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" };	154818	const sub_src0_elem_size_mul_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_mul_src1, .op = .mul, .rhs = .@"1" };
		154819	const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" };
151818	const add_src1_div_8_down_4: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .div_8_down, .rhs = .@"4" };	154820	const add_src1_div_8_down_4: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .div_8_down, .rhs = .@"4" };
151819	const add_src1_rem_32: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"4" };	154821	const add_src1_rem_32: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"4" };
151820	const add_src1_rem_64: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"8" };	154822	const add_src1_rem_64: Adjust = .{ .sign = .pos, .lhs = .src1, .op = .rem_8_mul, .rhs = .@"8" };
151821	const add_src1_sub_bit_size: Adjust = .{ .sign = .pos, .lhs = .src1_sub_bit_size, .op = .mul, .rhs = .@"1" };	154823	const add_src1_sub_bit_size: Adjust = .{ .sign = .pos, .lhs = .src1_sub_bit_size, .op = .mul, .rhs = .@"1" };
151822	const add_log2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .log2_src0_elem_size, .op = .mul, .rhs = .@"1" };	154824	const add_log2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .log2_src0_elem_size, .op = .mul, .rhs = .@"1" };
151823	const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" };
151824	const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" };	154825	const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" };
151825	const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" };	154826	const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" };
151826	const add_2_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"2" };	154827	const add_2_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"2" };
...	@@ -152841,7 +155842,10 @@ fn select(	...	@@ -152841,7 +155842,10 @@ fn select(
152841	},	155842	},
152842	}	155843	}
152843	}	155844	}
152844	for (dst_temps, case.dst_temps[0..dst_temps.len]) \|dst_temp, tmp_kind\| tmp_kind.finish(dst_temp, cg);	155845	for (case.dst_temps[0..dst_temps.len], dst_temps, dst_tys) \|tmp_kind, dst_temp, dst_ty\| {
		155846	tmp_kind.finish(dst_temp, cg);
		155847	cg.temp_type[@intFromEnum(dst_temp.unwrap(cg).temp)] = dst_ty;
		155848	}
152845	for (tmp_owned, s_tmp_temps) \|owned, temp\| if (owned) try temp.die(cg);	155849	for (tmp_owned, s_tmp_temps) \|owned, temp\| if (owned) try temp.die(cg);
152846	return;	155850	return;
152847	}	155851	}

test/behavior/array.zig-1

...	@@ -970,7 +970,6 @@ test "store array of array of structs at comptime" {	...	@@ -970,7 +970,6 @@ test "store array of array of structs at comptime" {
970	}	970	}
971		971
972	test "accessing multidimensional global array at comptime" {	972	test "accessing multidimensional global array at comptime" {
973	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
974	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	973	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
975	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	974	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
976	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	975	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

test/behavior/cast.zig-1

...	@@ -2714,7 +2714,6 @@ test "result type is preserved into comptime block" {	...	@@ -2714,7 +2714,6 @@ test "result type is preserved into comptime block" {
2714	}	2714	}
2715		2715
2716	test "bitcast vector" {	2716	test "bitcast vector" {
2717	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
2718	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	2717	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2719	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2718	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2720		2719

test/behavior/packed-struct.zig-1

...	@@ -1164,7 +1164,6 @@ test "assignment to non-byte-aligned field in packed struct" {	...	@@ -1164,7 +1164,6 @@ test "assignment to non-byte-aligned field in packed struct" {
1164	}	1164	}
1165		1165
1166	test "packed struct field pointer aligned properly" {	1166	test "packed struct field pointer aligned properly" {
1167	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1168	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1167	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1169	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1168	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1170	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1169	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO

test/behavior/sizeof_and_typeof.zig-1

...	@@ -326,7 +326,6 @@ test "lazy abi size used in comparison" {	...	@@ -326,7 +326,6 @@ test "lazy abi size used in comparison" {
326	}	326	}
327		327
328	test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {	328	test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {
329	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
330	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	329	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
331	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	330	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
332	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	331	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

test/behavior/slice.zig-4

test/behavior/struct.zig-4

test/behavior/try.zig-2

...	@@ -47,7 +47,6 @@ test "try then not executed with assignment" {	...	@@ -47,7 +47,6 @@ test "try then not executed with assignment" {
47	}	47	}
48		48
49	test "`try`ing an if/else expression" {	49	test "`try`ing an if/else expression" {
50	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
52	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
53	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	52	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
...	@@ -69,7 +68,6 @@ test "`try`ing an if/else expression" {	...	@@ -69,7 +68,6 @@ test "`try`ing an if/else expression" {
69	}	68	}
70		69
71	test "'return try' of empty error set in function returning non-error" {	70	test "'return try' of empty error set in function returning non-error" {
72	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
75	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;	73	if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;

test/behavior/undefined.zig-1

...	@@ -89,7 +89,6 @@ test "type name of undefined" {	...	@@ -89,7 +89,6 @@ test "type name of undefined" {
89	var buf: []u8 = undefined;	89	var buf: []u8 = undefined;
90		90
91	test "reslice of undefined global var slice" {	91	test "reslice of undefined global var slice" {
92	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
93	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
94	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
95	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	94	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

test/behavior/union.zig-2

...	@@ -2129,7 +2129,6 @@ test "copied union field doesn't alias source" {	...	@@ -2129,7 +2129,6 @@ test "copied union field doesn't alias source" {
2129	}	2129	}
2130		2130
2131	test "create union(enum) from other union(enum)" {	2131	test "create union(enum) from other union(enum)" {
2132	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
2133	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	2132	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2134	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2133	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2135	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	2134	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
...	@@ -2254,7 +2253,6 @@ test "matching captures causes union equivalence" {	...	@@ -2254,7 +2253,6 @@ test "matching captures causes union equivalence" {
2254	}	2253	}
2255		2254
2256	test "signed enum tag with negative value" {	2255	test "signed enum tag with negative value" {
2257	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
2258	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	2256	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2259	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	2257	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2260	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	2258	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

test/behavior/vector.zig-2

...	@@ -1548,7 +1548,6 @@ test "index into comptime-known vector is comptime-known" {	...	@@ -1548,7 +1548,6 @@ test "index into comptime-known vector is comptime-known" {
1548	}	1548	}
1549		1549
1550	test "arithmetic on zero-length vectors" {	1550	test "arithmetic on zero-length vectors" {
1551	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1552	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1551	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1553	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1552	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1554	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1553	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
...	@@ -1567,7 +1566,6 @@ test "arithmetic on zero-length vectors" {	...	@@ -1567,7 +1566,6 @@ test "arithmetic on zero-length vectors" {
1567		1566
1568	test "@reduce on bool vector" {	1567	test "@reduce on bool vector" {
1569	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	1568	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1570	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1571	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1569	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1572	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1570	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1573		1571

test/behavior/x86_64/unary.zig+8

...	@@ -4881,6 +4881,14 @@ test reduceXor {	...	@@ -4881,6 +4881,14 @@ test reduceXor {
4881	try test_reduce_xor.testIntVectors();	4881	try test_reduce_xor.testIntVectors();
4882	}	4882	}
4883		4883
		4884	inline fn reduceAdd(comptime Type: type, rhs: Type) @typeInfo(Type).vector.child {
		4885	return @reduce(.Add, rhs);
		4886	}
		4887	test reduceAdd {
		4888	const test_reduce_add = unary(reduceAdd, .{});
		4889	try test_reduce_add.testIntVectors();
		4890	}
		4891
4884	inline fn splat(comptime Type: type, rhs: Type) Type {	4892	inline fn splat(comptime Type: type, rhs: Type) Type {
4885	return @splat(rhs[0]);	4893	return @splat(rhs[0]);
4886	}	4894	}

...	@@ -994,7 +994,6 @@ test "modify slice length at comptime" {	...	@@ -994,7 +994,6 @@ test "modify slice length at comptime" {
994	}	994	}
995		995
996	test "slicing zero length array field of struct" {	996	test "slicing zero length array field of struct" {
997	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
998	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	997	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
999	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	998	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1000	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	999	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
...	@@ -1011,7 +1010,6 @@ test "slicing zero length array field of struct" {	...	@@ -1011,7 +1010,6 @@ test "slicing zero length array field of struct" {
1011	}	1010	}
1012		1011
1013	test "slicing slices gives correct result" {	1012	test "slicing slices gives correct result" {
1014	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1015	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1013	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1016	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1014	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1017	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1015	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
...	@@ -1026,7 +1024,6 @@ test "slicing slices gives correct result" {	...	@@ -1026,7 +1024,6 @@ test "slicing slices gives correct result" {
1026	}	1024	}
1027		1025
1028	test "get address of element of zero-sized slice" {	1026	test "get address of element of zero-sized slice" {
1029	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1030	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1027	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1031	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1028	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1032	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1029	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
...	@@ -1040,7 +1037,6 @@ test "get address of element of zero-sized slice" {	...	@@ -1040,7 +1037,6 @@ test "get address of element of zero-sized slice" {
1040	}	1037	}
1041		1038
1042	test "sentinel-terminated 0-length slices" {	1039	test "sentinel-terminated 0-length slices" {
1043	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1044	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1040	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1045	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1041	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1046	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1042	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;

...	@@ -1835,7 +1835,6 @@ test "tuple with comptime-only field" {	...	@@ -1835,7 +1835,6 @@ test "tuple with comptime-only field" {
1835	}	1835	}
1836		1836
1837	test "extern struct fields are aligned to 1" {	1837	test "extern struct fields are aligned to 1" {
1838	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1839	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1838	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1840	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1839	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1841		1840
...	@@ -1905,7 +1904,6 @@ test "array of structs inside struct initialized with undefined" {	...	@@ -1905,7 +1904,6 @@ test "array of structs inside struct initialized with undefined" {
1905	}	1904	}
1906		1905
1907	test "runtime call in nested initializer" {	1906	test "runtime call in nested initializer" {
1908	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1909	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1907	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1910	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1908	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1911	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;	1909	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
...	@@ -1938,7 +1936,6 @@ test "runtime call in nested initializer" {	...	@@ -1938,7 +1936,6 @@ test "runtime call in nested initializer" {
1938	}	1936	}
1939		1937
1940	test "runtime value in nested initializer passed as pointer to function" {	1938	test "runtime value in nested initializer passed as pointer to function" {
1941	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1942	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1939	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1943	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1940	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1944		1941
...	@@ -1963,7 +1960,6 @@ test "runtime value in nested initializer passed as pointer to function" {	...	@@ -1963,7 +1960,6 @@ test "runtime value in nested initializer passed as pointer to function" {
1963	}	1960	}
1964		1961
1965	test "struct field default value is a call" {	1962	test "struct field default value is a call" {
1966	if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1967	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1963	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1968	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1964	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1969	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO	1965	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO